线程小酌之理解线程池
Posted tanyunlong_nice
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了线程小酌之理解线程池相关的知识，希望对你有一定的参考价值。
一、引言
在学习JAVASE部分中，我们都学习到了基本的线程创建继承THREAD类或实现Runnable接口，在正常负载情况下，为每个任务分配一个线程这种方法能够提升串行执行的性能。只要请求的导弹速率不超出服务器的请求处理能力，那么这种方法可以同时带来更快的响应性和更高的吞吐率。但是在实际开发过程中，开发环境和测试环境因数据流量并没有达到实际请求流量，并不能发现实际的问题，在生产环境中，为每个任务分配一个线程这种方法存在一些缺陷，尤其是当需要创建大量的线程时：
1、线程的生命周期的开销非常高
线程的创建于销毁并不是没有代价的。每一个线程的创建都会需要时间，延迟处理的请求，并且需要JVM和操作系统提供一些辅助操作。
2、资源消耗：
活跃的线程会消耗系统资源，尤其是内存。如果可运行的线程数量多于可用处理器的数量，那么有些线程将闲置，大量空闲的线程会占用许多内存，给垃圾回收器带来压力，而且大量线程在竞争CPU资源时，还将产生其他性能开销，那么再创建更多的线程反而会降低性能。
3、稳定性
在可创建线程的数量上存在一个限制。如果破坏了这些限制，那么很可能抛出OutOfMemoryError异常。
因此，在jdk1.5之后这一情况有了很大的改观。Jdk1.5之后加入了java.util.concurrent包，这个包中主要介绍java中线程以及线程池的使用。为我们在开发中处理线程的问题提供了非常大的帮助，这里主要讲解Executor框架。
二、我们为什么要使用线程池
合理利用线程池能够带来三个好处。第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二：提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。但是要做到合理的利用线程池，必须对其原理了如指掌。
三、Executor框架
Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。下面这张图完整描述了线程池的类体系结构。
标记一下比较重要的类：
| ExecutorService： | 真正的线程池接口。 |
| ScheduledExecutorService | 能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。 |
| ThreadPoolExecutor | ExecutorService的默认实现。 |
| ScheduledThreadPoolExecutor | 继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。 |
到这里，大家应该明白了ThreadPoolExecutor、AbstractExecutorService、ExecutorService和Executor几个之间的关系了。
Executor是一个顶层接口，在它里面只声明了一个方法execute(Runnable)，返回值为void，参数为Runnable类型，从字面意思可以理解，就是用来执行传进去的任务的；
然后ExecutorService接口继承了Executor接口，并声明了一些方法：submit、invokeAll、invokeAny以及shutDown等；
抽象类AbstractExecutorService实现了ExecutorService接口，基本实现了ExecutorService中声明的所有方法；
然后ThreadPoolExecutor继承了类AbstractExecutorService。
通过适当的调整线程池的大小，可以创建足够多的线程以便使处理器保持忙碌状态，同时还可以防止过多线程相互竞争资源而使应用程序耗尽内存或失败。
ThreadPoolExecutor类库提供了一个灵活的线程池以及一些有用的默认配置。可以通过调用Executors中的静态工厂方法之一来创建一个线程池：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
(1) newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：
package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest
public static void main(String[] args)
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++)
final int index = i;
try
Thread.sleep(index * 1000);
catch (InterruptedException e)
e.printStackTrace();
cachedThreadPool.execute(new Runnable()
public void run()
System.out.println(index);
);
线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
使用场景：
1.耗时较短的任务
2.任务处理速度 > 任务提交速度 ，这样才能保证不会不断创建新的进程，避免内存被占满。
取名为cached-threadpool的原因在于线程池中的线程是被线程池缓存了的，也就是说，线程没有任务要执行时，便处于空闲状态，处于空闲状态的线程并不会被立即销毁（会被缓存住），只有当空闲时间超出一段时间(默认为60s)后，线程池才会销毁该线程（相当于清除过时的缓存）。新任务到达后，线程池首先会让被缓存住的线程（空闲状态）去执行任务，如果没有可用线程（无空闲线程），便会创建新的线程。
(2) newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：
package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest
public static void main(String[] args)
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++)
final int index = i;
fixedThreadPool.execute(new Runnable()
public void run()
try
System.out.println(index);
Thread.sleep(2000);
catch (InterruptedException e)
e.printStackTrace();
);
因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors() (3) newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：
package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest
public static void main(String[] args)
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable()
public void run()
System.out.println("delay 3 seconds");
, 3, TimeUnit.SECONDS);
表示延迟3秒执行。
定期执行示例代码如下：
package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest
public static void main(String[] args)
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.scheduleAtFixedRate(new Runnable()
public void run()
System.out.println("delay 1 seconds, and excute every 3 seconds");
, 1, 3, TimeUnit.SECONDS);
表示延迟1秒后每3秒执行一次。
(4) newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：
package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest
public static void main(String[] args)
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++)
final int index = i;
singleThreadExecutor.execute(new Runnable()
public void run()
try
System.out.println(index);
Thread.sleep(2000);
catch (InterruptedException e)
e.printStackTrace();
);
向线程池提交任务
我们可以使用execute提交的任务，但是execute方法没有返回值，所以无法判断任务知否被线程池执行成功。通过以下代码可知execute方法输入的任务是一个Runnable类的实例。
01 | threadsPool.execute(new Runnable() |
02 | @Override |
03 |
04 | public void run() |
05 |
06 | // TODO Auto-generated method stub |
07 |
08 | |
09 |
10 | ); |
我们也可以使用submit 方法来提交任务，它会返回一个future,那么我们可以通过这个future来判断任务是否执行成功，通过future的get方法来获取返回值，get方法会阻塞住直到任务完成，而使用get(long timeout, TimeUnit unit)方法则会阻塞一段时间后立即返回，这时有可能任务没有执行完。
01 | try |