大数据处理之Java线程池使用

大数据处理之Java线程池使用

前言：最近在做分布式海量数据处理项目，使用到了java的线程池，所以搜集了一些资料对它的使用做了一下总结和探究，

前面介绍的东西大多都是从网上搜集整理而来。文中最核心的东西在于后面两节无界队列线程池和有界队列线程池的实例使用以及线上问题处理方案。

1. 为什么要用线程池？

在Java中，如果每当一个请求到达就创建一个新线程，开销是相当大的。在实际使用中，每个请求创建新线程的服务器

在创建和销毁线程上花费的时间和消耗的系统资源，甚至可能要比花在实际处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个JVM中创建太多的线程，可能会导致系统由于过度消耗内存或者“切换过度”而导致系统资源不足。为了防止资源不足，服务器应用程序需要一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务，这就是“池化资源”技术产生的原因。

线程池主要用来解决线程生命周期开销问题和资源不足问题，通过对多个任务重用线程，线程创建的开销被分摊到多个任务上了，而且由于在请求到达时线程已经存在，所以消除了创建所带来的延迟。这样，就可以立即请求服务，使应用程序响应更快。另外，通过适当的调整线程池中的线程数据可以防止出现资源不足的情况。

网上找来的这段话，清晰的描述了为什么要使用线程池，使用线程池有哪些好处。工程项目中使用线程池的场景比比皆是。

本文关注的重点是如何在实战中来使用好线程池这一技术，来满足海量数据大并发用户请求的场景。

2. ThreadPoolExecutor类

Java中的线程池技术主要用的是ThreadPoolExecutor 这个类。先来看这个类的构造函数，

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,

BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

corePoolSize 线程池维护线程的最少数量

maximumPoolSize 线程池维护线程的最大数量

keepAliveTime 线程池维护线程所允许的空闲时间

workQueue 任务队列，用来存放我们所定义的任务处理线程

threadFactory 线程创建工厂

handler 线程池对拒绝任务的处理策略

ThreadPoolExecutor 将根据 corePoolSize和 maximumPoolSize 设置的

边界自动调整池大小。当新任务在方法execute(Runnable) 中提交时，如果运行的线程少于 corePoolSize，则创建新线程来处理请求，即使其他辅助线程是空闲的。如果运行的线程多于 corePoolSize 而少于 maximumPoolSize，则仅当队列满时才创建新线程。如果设置的corePoolSize 和 maximumPoolSize 相同，则创建了固定大小的线程池。

ThreadPoolExecutor是Executors类的实现，Executors类里面提供了一些静态工厂，生成一些常用的线程池，主要有以下几个：

newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

在实际的项目中，我们会使用得到比较多的是newFixedThreadPool，创建

固定大小的线程池，但是这个方法在真实的线上环境中还是会有很多问题，这个将会在下面一节中详细讲到。

当任务源源不断的过来，而我们的系统又处理不过来的时候，我们要采取的策略是拒绝服务。RejectedExecutionHandler接口提供了拒绝任务处理的自定义方法的机会。在ThreadPoolExecutor中已经包含四种处理策略。

1）CallerRunsPolicy：线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) {

r.run();

}

}

这个策略显然不想放弃执行任务。但是由于池中已经没有任何资源了，那么就直接使用调用该execute的线程本身来执行。

2）AbortPolicy：处理程序遭到拒绝将抛出运行时RejectedExecutionException

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { throw new RejectedExecutionException();

}

这种策略直接抛出异常，丢弃任务。

3）DiscardPolicy：不能执行的任务将被删除

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {} 这种策略和AbortPolicy几乎一样，也是丢弃任务，只不过他不抛出异常。

4）DiscardOldestPolicy：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) {

e.getQueue().poll();

e.execute(r);

}

该策略就稍微复杂一些，在pool没有关闭的前提下首先丢掉缓存在队列中的最早的任务，然后重新尝试运行该任务。这个策略需要适当小心。

3. ThreadPoolExecutor无界队列使用

public class ThreadPool {

private final static String poolName = "mypool";

static private ThreadPool threadFixedPool = new ThreadPool(2);

private ExecutorService executor;

static public ThreadPool getFixedInstance() {

return threadFixedPool;

}

private ThreadPool(int num) {

executor = Executors.newFixedThreadPool(num, new DaemonThreadFactory(poolName));

}

public void execute(Runnable r) {

executor.execute(r);

}

public static void main(String[] params) {

class MyRunnable implements Runnable {

public void run() {

System.out.println("OK!");

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

for (int i = 0; i <10; i ) {

ThreadPool.getFixedInstance().execute(new MyRunnable());

}

try {

Thread.sleep(2000);

System.out.println("Process end.");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

在这段代码中，我们发现我们用到了Executors.newFixedThreadPool（）

函数，这个函数的实现是这样子的：

return new ThreadPoolExecutor(nThreads, nThreads, 0L,

https://www.wendangku.net/doc/6d10591425.html,LISECONDS,new LinkedBlockingQueue());

它实际上是创建了一个无界队列的固定大小的线程池。执行这段代码，我们发现所有的任务都正常处理了。但是在真实的线上环境中会存在这样的一个问题，前端的用户请求源源不断的过来，后端的处理线程如果处理时间变长，无法快速的将用户请求处理完返回结果给前端，那么任务队列中将堵塞大量的请求。这些请求在前端都是有超时时间设置的，假设请求是通过套接字过来，当我们的后端处理进程处理完一个请求后，从队列中拿下一个任务，发现这个任务的套接字已经无效了，这是因为在用户端已经超时，将套接字建立的连接关闭了。这样一来我们这边的处理程序再去读取套接字时，就会发生I/0 Exception. 恶性循环，导致我们所有的处理服务线程读的都是超时的套接字，所有的请求过来都抛I/O异常，这样等于我们整个系统都挂掉了，已经无法对外提供正常的服务了。

对于海量数据的处理，现在业界都是采用集群系统来进行处理，当请求的数量不断加大的时候，我们可以通过增加处理节点，反正现在硬件设备相对便宜。

但是要保证系统的可靠性和稳定性，在程序方面我们还是可以进一步的优化的，我们下一节要讲述的就是针对线上出现的这类问题的一种处理策略。

4. ThreadPoolExecutor有界队列使用

public class ThreadPool {

private final static String poolName = "mypool";

static private ThreadPool threadFixedPool = null;

public ArrayBlockingQueue queue = new ArrayBlockingQueue(2);

private ExecutorService executor;

static public ThreadPool getFixedInstance() {

return threadFixedPool;

}

private ThreadPool(int num) {

executor = new ThreadPoolExecutor(2, 4,60,TimeUnit.SECONDS, queue,new DaemonThreadFactory

(poolName), new ThreadPoolExecutor.AbortPolicy());

}

public void execute(Runnable r) {

executor.execute(r);

}

public static void main(String[] params) {

class MyRunnable implements Runnable {

public void run() {

System.out.println("OK!");

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

int count = 0;

for (int i = 0; i <10; i ) {

try {

ThreadPool.getFixedInstance().execute(new MyRunnable());

} catch (RejectedExecutionException e) {

e.printStackTrace();

count ;

}

}

try {

https://www.wendangku.net/doc/6d10591425.html,("queue size:"

ThreadPool.getFixedInstance().queue.size());

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Reject task: " count);

}

}

首先我们来看下这段代码几个重要的参数，corePoolSize 为2，maximumPoolSize为4，任务队列大小为2，每个任务平均处理时间为10ms,一共有10个并发任务。

执行这段代码，我们会发现，有4个任务失败了。这里就验证了我们在上面提到有界队列时候线程池的执行顺序。当新任务在方法 execute(Runnable) 中提交时，如果运行的线程少于 corePoolSize，则创建新线程来处理请求。如果运行的线程多于corePoolSize 而少于 maximumPoolSize，则仅当队列满时才创建新线程，如果此时线程数量达到maximumPoolSize,并且队列已经满，就会拒绝继续进来的请求。

现在我们调整一下代码中的几个参数，将并发任务数改为200，执行结果Reject task: 182，说明有18个任务成功了，线程处理完一个请求后会接着去处理下一个过来的请求。在真实的线上环境中，会源源不断的有新的请求过来，当前的被拒绝了，但只要线程池线程把当下的任务处理完之后还是可以处理下一个发送过来的请求。

通过有界队列可以实现系统的过载保护，在高压的情况下，我们的系统处理能力不会变为0，还能正常对外进行服务，虽然有些服务可能会被拒绝，至于如何减少被拒绝的数量以及对拒绝的请求采取何种处理策略我将会在下一篇文章《系统的过载保护》中继续

阐述。

参考文献：

ThreadPoolExecutor使用与思考（上）-线程池大小设置与BlockedQueue 的三种实现区别 /blog/901689

ThreadPoolExecutor使用与思考（中）-keepAliveTime及拒绝策略

/blog/902571

ThreadPoolExecutor源代码

Java线程池介绍以及简单实例 /view/e4543a7a5acfa1c7aa00cc25.html

JAVA线程池原理333

在什么情况下使用线程池？ 1.单个任务处理的时间比较短 2.将需处理的任务的数量大 使用线程池的好处: 1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 线程池工作原理：

线程池为线程生命周期开销问题和资源不足问题提供了解决方案。通过对多个任务重用线程，线程创建的开销被分摊到了多个任务上。其好处是，因为在请求到达时线程已经存在，所以无意中也消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使应用程序响应更快。而且，通过适当地调整线程池中的线程数目，也就是当请求的数目超过某个阈值时，就强制其它任何新到的请求一直等待，直到获得一个线程来处理为止，从而可以防止资源不足。 线程池的替代方案 线程池远不是服务器应用程序内使用多线程的唯一方法。如同上面所提到的，有时，为每个新任务生成一个新线程是十分明智的。然而，如果任务创建过于频繁而任务的平均处理时间过短，那么为每个任务生成一个新线程将会导致性能问题。 另一个常见的线程模型是为某一类型的任务分配一个后台线程与任务队列。AWT 和 Swing 就使用这个模型，在这个模型中有一个 GUI 事件线程，导致用户界面发生变化的所有工作都必须在该线程中执行。然而，由于只有一个 AWT 线程，因此要在 AWT 线程中执行任务可能要花费相当长时间才能完成，这是不可取的。因此，Swing 应用程序经常需要额外的工作线程，用于运行时间很长的、同 UI 有关的任务。 每个任务对应一个线程方法和单个后台线程（single-background-thread）方法在某些情形下都工作得非常理想。每个任务一个线程方法在只有少量运行时间很长的任务时工作得十分好。而只要调度可预见性不是很重要，则单个后台线程方法就工作得十分好，如低优先级后台任务就是这种情况。然而，大多数服务器应用程序都是面向处理大量的短期任务或子任务，因此往往希望具有一种能够以低开销有效地处理这些任务的机制以及一些资源管理和定时可预见性的措施。线程池提供了这些优点。 工作队列 就线程池的实际实现方式而言，术语“线程池”有些使人误解，因为线程池“明显的”实现在大多数情形下并不一定产生我们希望的结果。术语“线程池”先于Java 平台出现，因此它可能是较少面向对象方法的产物。然而，该术语仍继续广泛应用着。 虽然我们可以轻易地实现一个线程池类，其中客户机类等待一个可用线程、将任务传递给该线程以便执行、然后在任务完成时将线程归还给池，但这种方法却存在几个潜在的负面影响。例如在池为空时，会发生什么呢？试图向池线程传递任务的调用者都会发现池为空，在调用者等待一个可用的池线程时，它的线程将阻塞。我们之所以要使用后台线程的原因之一常常是为了防止正在提交的线程被阻塞。完全堵住调用者，如在线程池的“明显的”实现的情况，可以杜绝我们试图解决的问题的发生。 我们通常想要的是同一组固定的工作线程相结合的工作队列，它使用 wait() 和

Java多线程技术及案例

Java多线程技术及案例 进程和线程： 进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。 多进程是指操作系统能同时运行多个任务（程序）。 多线程是指在同一程序中有多个顺序流在执行。 Java中多线程的多种实现方式 Java中有多种多线程实现方法，主要是继承https://www.wendangku.net/doc/6d10591425.html,ng.Thread类的方法和 https://www.wendangku.net/doc/6d10591425.html,ng.Runnable接口的方法。 继承Thread类 Thread是https://www.wendangku.net/doc/6d10591425.html,ng包中的一个类，从这个类中实例化的对象代表线程，启动一个新线程需要建立一个Thread实例。 使用Thread类启动新的线程的步骤如下： 1.实例化Thread对象 2.调用start()方法启动线程 构造方法：

public Thread(String threadName); public Thread(); 例程： publicclass Thread1extends Thread{//定义一个类继承Thread privateint count=1000; publicvoid run(){//重写run方法 while(true){ System.out.print(count+" "); if(--count==0){ return; } } } publicstaticvoid main(String[] args){ Thread1 th1=new Thread1();//实例化继承了Thread的类 Thread1 th2=new Thread1(); th1.start();//调用start()方法， th2.start(); for(int i=0;i<1000;i++){ System.out.print("A "); } }

手把手教你做一个java线程池小例子

废话不多说开整 我用的是eclipse（这应该没多大影响） 建一个工程java工程和web工程都行然后建一个包建一个类带main方法 首先贴出来的是内部类 //继承了runnable接口 class MyTask implements Runnable { private int taskNum; public MyTask(int num) { this.taskNum = num; } @Override public void run() { System.out.println("正在执行task "+taskNum); try { //写业务 Thread.currentThread().sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("task "+taskNum+"执行完毕！"); } } 接下来就是这个类 public class testOne { public static void main(String[] args) { ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 7, 10, https://www.wendangku.net/doc/6d10591425.html,LISECONDS, new ArrayBlockingQueue(2),new ThreadPoolExecutor.DiscardOldestPolicy() );

for(int i=0;i<15;i++){ MyTask myTask = new MyTask(i); executor.execute(myTask); System.out.println("线程池中线程数目： "+executor.getPoolSize()+"队列等待执行的任务数目："+ executor.getQueue().size()+"已经执行完别的任务数目： "+executor.getCompletedTaskCount()); } executor.shutdown(); } } 接下来在说明一下ThreadPoolExecutor的参数设置ThreadPoolExecutor(int corePoolSize,//线程池维护线程的最少数量 int maximumPoolSize,//线程池维护线程的最大数量 long keepAliveTime,//线程池维护线程所允许的空闲时间 TimeUnit unit, 线程池维护线程所允许的空闲时间单位 BlockingQueue workQueue,线程池所使用的缓存队列 RejectedExecutionHandler handler线程池对拒绝任务的处理策略 ) handler有四个选择： ThreadPoolExecutor.AbortPolicy() 抛出java.util.concurrent.RejectedExecutionException异常 ThreadPoolExecutor.CallerRunsPolicy() 重试添加当前的任务，他会自动重复调用execute()方法 ThreadPoolExecutor.DiscardOldestPolicy() 抛弃旧的任务 ThreadPoolExecutor.DiscardPolicy() 抛弃当前的任务 上面是一个例子接下来再来一个例子

java深入理解线程池

深入研究线程池 一.什么是线程池? 线程池就是以一个或多个线程[循环执行]多个应用逻辑的线程集合. 注意这里用了线程集合的概念是我生造的,目的是为了区分执行一批应用逻辑的多个线程和 线程组的区别.关于线程组的概念请参阅基础部分. 一般而言,线程池有以下几个部分: 1.完成主要任务的一个或多个线程. 2.用于调度管理的管理线程. 3.要求执行的任务队列. 那么如果一个线程循环执行一段代码是否是线程池? 如果极端而言,应该算,但实际上循环代码应该算上一个逻辑单元.我们说最最弱化的线程池 应该是循环执行多个逻辑单元.也就是有一批要执行的任务,这些任务被独立为多个不同的执行单元.比如: int x = 0; while(true){ x ++; } 这就不能说循环中执行多个逻辑单元,因为它只是简单地对循环外部的初始变量执行++操作. 而如果已经有一个队列 ArrayList al = new ArrayList(); for(int i=0;i<10000;i++){ al.add(new AClass()); } 然后在一个线程中执行: while(al.size() != 0){ AClass a = (AClass)al.remove(0); a.businessMethod(); } 我们说这个线程就是循环执行多个逻辑单元.可以说这个线程是弱化的线程池.我们习惯上把这些相对独立的逻辑单元称为任务. 二.为什么要创建线程池? 线程池属于对象池.所有对象池都具有一个非常重要的共性,就是为了最大程度复用对象.那么 线程池的最重要的特征也就是最大程度利用线程. 从编程模型模型上说讲,在处理多任务时,每个任务一个线程是非常好的模型.如果确实可以这么做我们将可以使用编程模型更清楚,更优化.但是在实际应用中,每个任务一个线程会使用系统限入"过度切换"和"过度开销"的泥潭. 打个比方,如果可能,生活中每个人一辆房车,上面有休息,娱乐,餐饮等生活措施.而且道路交道永远不堵车,那是多么美好的梦中王国啊.可是残酷的现实告诉我们,那是不可能的.不仅每个人一辆车需要无数多的社会资源,而且地球上所能容纳的车辆总数是有限制的. 首先,创建线程本身需要额外(相对于执行任务而必须的资源)的开销.

运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接

运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接 最近在项目中可能要用到socket相关的东西来发送消息，所以初步研究了下socket 的TCP和UDP实现方式，并且结合java1.5的concurrent.ExecutorService类来实现多线程。 具体实现方式见代码： 一、TCP方式： 1、服务端实现方式： TCP的服务端实现方式主要用到ServerSocket类，接收等待客户端连接的方法是accept(); 代码如下：类SocketServerTCP 1private int port=8823; 2private ServerSocket serverSocket; 3private ExecutorService executorService;//线程池 4private final int POOL_SIZE=100;//单个CPU线程池大小 5 6public SocketServerTCP(){ 7try{ 8serverSocket=new ServerSocket(port); 9executorService= Executors.newFixedThreadPool(Runtime.getRuntime() 10.availableProcessors()*POOL_SIZE); https://www.wendangku.net/doc/6d10591425.html,("端口号为"+port+"的服务器启动"); 12}catch(IOException e){ 13 e.printStackTrace(); 14} 15} 16 17public void service(){ 18System.out.println("socket初始化成功！"); https://www.wendangku.net/doc/6d10591425.html,("socket服务端初始化成功！"); 20while(true){ 21Socket socket=null; 22try{ 23//接收客户连接,只要客户进行了连接,就会触发accept();从而建立连接

java线程池_2

线程池的作用: 线程池作用就是限制系统中执行线程的数量。 根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。 为什么要用线程池: 1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务 2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为因为消耗过多的 内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机) 线程池类 Java代码 1.package com.tdt.impl.ls; 2. 3.import java.util.LinkedList; 4. 5./** 6. * @project LocationGateway 7. * @author sunnylocus 8. * @verson 1.0.0 9. * @date Aug 2, 2008 10. * @jdk 1.4.2 11. */ 12.public class ThreadPool extends ThreadGroup { 13. private boolean isClosed = false; //线程池是否关闭 14. private LinkedList workQueue; //工作队列 15. private static int threadPoolID = 1; //线程池的id 16. public ThreadPool(int poolSize) { //poolSize 表示线程池中 的工作线程的数量 17. 18. super(threadPoolID + ""); //指定ThreadGroup的名 称

最精简的java 线程池与任务队列

以下资料为java培训为大家整理： 1 import java.util.*; 2 public class WorkQueue 3 { 4 private final int nThreads;//线程池的大小 5 private final PoolWorker[] threads;//用数组实现线程池 6 private final LinkedList queue;//任务队列 7 8 public WorkQueue（int nThreads）{ 9 this.nThreads = nThreads; 10 queue = new LinkedList（）； 11 threads = new PoolWorker[nThreads]; 12 13 for （int i=0; i

21 queue.addLast（r）； 22 queue.notify（）； 23 } 24 } 25 26 private class PoolWorker extends Thread {//工作线程类 27 public void run（） { 28 Runnable r; 29 while （true） { 30 synchronized（queue） { 31 while （queue.isEmpty（）） {//如果任务队列中没有任务，等待 32 try{ 33 queue.wait（）； 34 }catch （InterruptedException ignored）{} 35 } 36 r = （Runnable） queue.removeFirst（）；//有任务时，取出任务 37 } 38 try { 39 r.run（）；//执行任务 40 }catch （RuntimeException e） { 41 // You might want to log something here 42 }

JAVA中的同步与异步问题 线程和线程池的重要知识

java线程同步与异步线程池 java线程同步与异步线程池 1）多线程并发时，多个线程同时请求同一个资源，必然导致此资源的数据不安全，A线程修改了B线 程的处理的数据，而B线程又修改了A线程处理的数理。显然这是由于全局资源造成的，有时为了解 决此问题，优先考虑使用局部变量，退而求其次使用同步代码块，出于这样的安全考虑就必须牺牲 系统处理性能，加在多线程并发时资源挣夺最激烈的地方，这就实现了线程的同步机制同步：A线程要请求某个资源，但是此资源正在被B线程使用中，因为同步机制存在，A线程请求 不到，怎么办，A线程只能等待下去 异步：A线程要请求某个资源，但是此资源正在被B线程使用中，因为没有同步机制存在，A线程 仍然请求的到，A线程无需等待

显然，同步最最安全，最保险的。而异步不安全，容易导致死锁，这样一个线程死掉就会导致整个 进程崩溃，但没有同步机制的存在，性能会有所提升 java中实现多线程 1）继承Thread,重写里面的run方法 2）实现runnable接口 Doug Lea比较推荐后者，第一，java没有单继承的限制第二，还可以隔离代码 线程池 要知道在计算机中任何资源的创建，包括线程，都需要消耗系统资源的。在WEB服务中，对于web服 务器的响应速度必须要尽可能的快，这就容不得每次在用户提交请求按钮后，再创建线程提供服务 。为了减少用户的等待时间，线程必须预先创建，放在线程池中，线程池可以用HashTable这种数

据结构来实现，看了Apach HTTP服务器的线程池的源代码，用是就是HashTable,KEY 用线程对象， value用ControlRunnable，ControlRunnable是线程池中唯一能干活的线程，是它指派线程池中的 线程对外提供服务。 出于安全考虑，Apach HTTP服务器的线程池它是同步的。听说weblogic有异步的实现方式，没有研 究过，不敢确定 --------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------一、关键字： thread（线程）、thread-safe(线程安全)、intercurrent（并发的） synchronized(同步的)、asynchronized(异步的)、 volatile（易变的）、atomic（原子的）、share（共享） 二、总结背景： 一次读写共享文件编写，嚯，好家伙，竟然揪出这些零碎而又是一路的知识点。于是乎，

JAVA集中常用的线程池比较

1. 为什么使用线程池 诸如Web 服务器、数据库服务器、文件服务器或邮件服务器之类的许多服务器应用程序都面向处理来自某些远程来源的大量短小的任务。请求以某种方式到达服务器，这种方式可能是通过网络协议（例如HTTP、FTP 或POP）、通过JMS 队列或者可能通过轮询数据库。不管请求如何到达，服务器应用程序中经常出现的情况是：单个任务处理的时间很短而请求的数目却是巨大的。 构建服务器应用程序的一个简单模型是：每当一个请求到达就创建一个新线程，然后在新线程中为请求服务。实际上对于原型开发这种方法工作得很好，但如果试图部署以这种方式运行的服务器应用程序，那么这种方法的严重不足就很明显。每个请求对应一个线程（thread-per-request）方法的不足之一是：为每个请求创建一个新线程的开销很大；为每个请求创建新线程的服务器在创建和销毁线程上花费的时间和消耗的系统资源要比花在处理实际的用户请求的时间和资源更多。 除了创建和销毁线程的开销之外，活动的线程也消耗系统资源。在一个JVM 里创建太多的线程可能会导致系统由于过度消耗内存而用完内存或“切换过度”。为了防止资源不足，服务器应用程序需要一些办法来限制任何给定时刻处理的请求数目。 线程池为线程生命周期开销问题和资源不足问题提供了解决方案。通过对多个任务重用线程，线程创建的开销被分摊到了多个任务上。其好处是，因为在请求到达时线程已经存在，所以无意中也消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使应用程序响应更快。而且，通过适当地调整线程池中的线程数目，也就是当请求的数目超过某个阈值时，就强制其它任何新到的请求一直等待，直到获得一个线程来处理为止，从而可以防止资源不足。 2. 使用线程池的风险 虽然线程池是构建多线程应用程序的强大机制，但使用它并不是没有风险的。用线程池构建的应用程序容易遭受任何其它多线程应用程序容易遭受的所有并发风险，诸如同步错误和死锁，它还容易遭受特定于线程池的少数其它风险，诸如与池有关的死锁、资源不足和线程泄漏。 2.1 死锁 任何多线程应用程序都有死锁风险。当一组进程或线程中的每一个都在等待一个只有该组中另一个进程才能引起的事件时，我们就说这组进程或线程死锁了。死锁的最简单情形是：线程 A 持有对象X 的独占锁，并且在等待对象Y 的锁，而线程 B 持有对象Y 的独占锁，却在等待对象X 的锁。除非有某种方法来打破对锁的等待（Java 锁定不支持这种方法），否则死锁的线程将永远等下去。 虽然任何多线程程序中都有死锁的风险，但线程池却引入了另一种死锁可能，在那种情况下，所有池线程都在执行已阻塞的等待队列中另一任务的执行结果的任务，但这一任务却因为没有未被占用的线程而不能运行。当线程池被用来实现涉及许多交互对象的模拟，被模拟的对象可以相互发送查询，这些查询接下来作为排队的任务执行，查询对象又同步等待着响应时，会发生这种情况。 2.2 资源不足 线程池的一个优点在于：相对于其它替代调度机制（有些我们已经讨论过）而言，它们通常执行得很好。但只有恰当地调整了线程池大小时才是这样的。线程消耗包括内存和其它系统资源在内的大量资源。除 了 Thread 对象所需的内存之外，每个线程都需要两个可能很大的执行调用堆栈。除此以外，JVM 可能会

Java并发类库提供的线程池有哪几种分别有什么特点

第八题 Java并发类库提供的线程池有哪几种？分别有什么特点？ 笔记本：Java面试题 创建时间：2018-10-30 11:14更新时间：2018-10-30 12:09 作者：这个名字其实还是很长很长的 Java并发类库提供的线程池有哪几种？分别有什么特点？ 经典回答: 通常开发者都是利用Executors提供的通用线程池创建方法,去创建不同配置的线程池,主要区别在于不同的ExecutorService类型或者不同的初识参数。 Executors目前提供了5种不同的线程池创建配置: newCachedThreadPool(),它是一种用来处理大量短时间工作任务的线程池,具有几个鲜明特点:它会试图缓存线程并重用,当无缓存线程可用时,就会创建新的工作线程;如果线程闲置的时间超过60S,则被终止并移出缓存;长时间闲置时,这种线程池,不会消耗资源。newFixedThreadPool(int nThreads),重用指定数目的线程,其背后使用的是无界的工作队列,任何时候最多有nThreads个工作线程是活动的。这意味着,如果任务数量超过了活动队列数目,将在工作队列中等待空闲线程出现;如果有工作线程退出,将会有新的工作线程被创建,以补足指定的数目nThreads。 newSingleThreadExecutor(),它的特点在于工作线程数目被限制为1,操作一个无界的工作队列,所以它保证了所有任务的都是被顺序执行,最多会有一个任务处于活动状态,并且不允许使用者改造线程实例,因此可以避免其改变线程数目。newSingleThreadScheduledExecutor()和newSecheduledThreadPool(int corePoolSize),创建的是个ScheduledExecutorService,可以进行定时或周期性的工作调度,区别在于单一工作线程还是多个工作线程。

深入理解Java多线程核心知识：跳槽面试必备

深入理解-Jaｖa-多线程核心知识：跳槽面试必备

————————————————————————————————作者：————————————————————————————————日期： ?

深入理解Java 多线程核心知识:跳槽面试必备 多线程相对于其他Jaｖa 知识点来讲,有一定的学习门槛,并且了解起来比较费劲。在平时工作中如若使用不当会出现数据错乱、执行效率低(还不如单线程去运行)或者死锁程序挂掉等等问题，所以掌握了解多线程至关重要。 本文从基础概念开始到最后的并发模型由浅入深,讲解下线程方面的知识。 概念梳理 本节我将带大家了解多线程中几大基础概念。 并发与并行 并行,表示两个线程同时做事情。 并发,表示一会做这个事情,一会做另一个事情，存在着调度。单核CPU 不可能存在并行(微观上）。 临界区 临界区用来表示一种公共资源或者说是共享数据，可以被多个线程使用。但是每一次,只能有一个线程使用它,一旦临界区资源被占用,其他线程要想使用这个资源，就必须等待。

阻塞与非阻塞 阻塞和非阻塞通常用来形容多线程间的相互影响。比如一个线程占用了临界区资源,那么其它所有需要这个资源的线程就必须在这个临界区中进行等待，等待会导致线程挂起。这种情况就是阻塞。 此时,如果占用资源的线程一直不愿意释放资源,那么其它所有阻塞在这个临界区上的线程都不能工作。阻塞是指线程在操作系统层面被挂起。阻塞一般性能不好,需大约８万个时钟周期来做调度。 非阻塞则允许多个线程同时进入临界区。 死锁 死锁是进程死锁的简称,是指多个进程循环等待他方占有的资源而无限的僵持下去的局面。

JAVA线程池实现实例

java线程池实现实例 线程池作用就是限制系统中执行线程的数量。 根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。 为什么要用线程池: 1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务 2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为因为消耗过多的 内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机) 线程池类 Java代码 1.package com.tdt.impl.ls; 2. 3.import java.util.LinkedList; 4. 5./** 6.*@project LocationGateway 7.*@author sunnylocus 8.*@verson 1.0.0 9.*@date Aug2,2008 10.*@jdk 1.4.2 11.*/ 12.public class ThreadPool extends ThreadGroup{ 13.private boolean isClosed=false;//线程池是否关 闭 14.private LinkedList workQueue;//工作队 列 15.private static int threadPoolID=1;//线程池的 id 16.public ThreadPool(int poolSize){//poolSize表 示线程池中的工作线程的数量

JAVA线程池介绍以及简单实例

JAVA线程池介绍以及简单实例 文章分类:Java编程 在什么情况下使用线程池？ 1.单个任务处理的时间比较短 2.将需处理的任务的数量大 使用线程池的好处: 1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 线程池工作原理： https://www.wendangku.net/doc/6d10591425.html,/developerworks/cn/java/j-jtp0730/ 该文章里有个例子，简单的描述了线程池的内部实现，建议根据里面的例子来了解JAVA 线程池的原理。同时，里面还详细描述了使用线程池存在的优点和弊端，大家可以研究下，我觉得是篇非常好的文章。

JDK自带线程池总类介绍介绍： 1、newFixedThreadPool创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。 2、newCachedThreadPool创建一个可缓存的线程池。这种类型的线程池特点是： 1).工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。 2).如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。 3、newSingleThreadExecutor创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，如果这个线程异常结束，会有另一个取代它，保证顺序执行(我觉得这点是它的特色)。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。 4、newScheduleThreadPool创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。(这种线程池原理暂还没完全

以实例Java中线程池的工作特点概论

以实例简介Java中线程池的工作特点 什么原因使我们不得不使用线程池？ 个人认为主要原因是：短时间内需要处理的任务数量很多 使用线程池的好处: 1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存 以下是Java自带的几种线程池： 1、newFixedThreadPool 创建一个指定工作线程数量的线程池。 每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。 2、newCachedThreadPool 创建一个可缓存的线程池。 这种类型的线程池特点是： 1).工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。 2).如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。 3、newSingleThreadExecutor 创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，如果这个线程异常结束，会有另一个取代它，保证顺序执行(我觉得这点是它的特色)。

单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。 4、newScheduleThreadPool 创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。 总结： 一.FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。 二．CachedThreadPool的特点就是在线程池空闲时，即线程池中没有可运行任务时，它会释放工作线程，从而释放工作线程所占用的资源。但是，但当出现新任务时，又要创建一新的工作线程，又要一定的系统开销。并且，在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。 Java线程池 ThreadPoolExecutor使用实例

Java线程池实现例子

这是我从网上裆下来的一个线程池例子,因为是菜鸟，也是看了有一会儿才看懂了，希望能帮到其他的菜鸟们; 说下实现思路: PoolManager:创建了一个ArrayList用来存放实例化好的线程对象:一个线程可以帮助一个任务去执行：工厂 Worker:也就是工人的意思:就是实例化好的线程，放到了线程池工厂里，有一批新货（任务）就找一个空闲的线程(工人)去做这件事：工厂里的工人 TaskManager:任务（新货）需要放到一个临时的仓库:这个类就是这个仓库：接到任务的工人从这个仓库里拿需要执行的任务:需要干的活的仓库 TaskNibutirThread:哪件事情由那个人去做，仓库里有没有货，工厂里有没有闲着的工人，都是这个类负责的:负责分配任务的主管 WorkTask:任务的接口其他的是它的实现类，用来放到仓库里执行的 package com.threadpool; import java.util.ArrayList; /* * 线程池管理器（PoolManager）:用于创建并管理线程池，采用单例模式 * */ public class PoolManager { public static PoolManager mPool=new PoolManager(); public final int max_pool =3; public final int max_Tasks = 15; public static ArrayList init_pools; // private int GetIdleThreadPollTime=50;//获取空闲线程轮询间隔时间,可配置 private TaskMonitorThread mainThread;//任务监测线程 static { init_pools = new ArrayList(5); } public static PoolManager getInstance() { if (mPool == null) { mPool = new PoolManager();