简单介绍线程池在并发编程中的使用

合法程序媛 2017-09-17 16:28

本文将从为什么要使用线程池以及怎样使用线程池两方面来介绍线程池在并发编程中的使用。

一、为什么要使用线程池

当需要处理的任务较少时，我们可以自己创建线程去处理，但在高并发场景下，我们需要处理的任务数量很多，由于创建销毁线程开销很大，这样频繁创建线程就会大大降低系统的效率。此时，我们就可以使用线程池，线程池中的线程执行完一个任务后可以复用，并不被销毁。合理使用线程池有以下几点好处：

1、减少资源的开销。通过复用线程，降低创建销毁线程造成的消耗。

2、多个线程并发执行任务，提高系统的响应速度。

3、可以统一的分配，调优和监控线程，提高线程的可管理性。

二、怎样使用线程池

1、创建线程池

通过ThreadPoolExecutor来创建一个线程池。

new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, milliseconds,runnableTaskQueue, threadFactory, handler);

java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类，它有四个构造方法。

public class ThreadPoolExecutor extends AbstractExecutorService {

.....

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit, BlockingQueue<Runnable> workQueue);

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

BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);

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

BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);

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

BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);

...

}

由源码可知，前三个构造器都是调用第四个构造器进行初始化。

各参数含义：

. corePoolSize（线程池的基本大小）：当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads方法，线程池会提前创建并启动所有基本线程。

. maximumPoolSize（线程池最大大小）：线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是如果使用了无界的任务队列这个参数就没什么效果。

. keepAliveTime（线程活动保持时间）：线程池的工作线程空闲后，保持存活的时间。所以如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高线程的利用率。

. TimeUnit（线程活动保持时间的单位）：可选的单位有天（DAYS），小时（HOURS），分钟（MINUTES），毫秒(MILLISECONDS)，微秒(MICROSECONDS, 千分之一毫秒)和毫微秒(NANOSECONDS, 千分之一微秒)。

. runnableTaskQueue（任务队列）：用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列。

(1) ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。

(2) LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。

(3) SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。

(4) PriorityBlockingQueue：一个具有优先级得无限阻塞队列。

.ThreadFactory：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字，Debug和定位问题时非常又帮助。

.Reje、ctedExecutionHandler（饱和策略）：当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。以下是JDK1.5提供的四种策略。n AbortPolicy：直接抛出异常。

(1) CallerRunsPolicy：只用调用者所在线程来运行任务。

(2) DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。

(3) DiscardPolicy：不处理，丢弃掉。

(4) 当然也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。

2、向线程池提交任务

使用execute提交任务，但execute()方法没有返回值，无法判断任务是否被线程池执行成功。execute方法输入的任务是一个Runnable类的实例。

execute(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

}

});

使用submit()方法提交任务，会返回一个future,那么我们可以通过这个future来判断任务是否执行成功。

3、线程池的关闭

调用shutdown()和shutdownNow()方法关闭线程池。

4、使用示例

这里我们选用第一种构造方法演示。

public class ThreadPoolTest {

public static void main(String[] args) {

ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(5));

for(int i=0;i<15;i++){

Task task = new Task(i);

executor.execute(task);

System.out.println("线程池中线程数:" + executor.getPoolSize() + ",队列中等待执行的任务数:" + executor.getQueue().size() +

",已执行完的任务数:" + executor.getCompletedTaskCount());

}

executor.shutdown();

}

}

class Task implements Runnable {

private int taskNum;

public Task(int num) {

this.taskNum = num;

}

@Override

public void run() {

System.out.println("task"+taskNum+“开始执行”);

try{

Thread.currentThread().sleep(4000);

}catch(InterruptedException e){

e.printStackTrace();

}

System.out.println("task"+taskNum+“执行完毕”);

}

}

}

执行结果:

task0开始执行

线程池中线程数:1,队列中等待执行的任务数:0,已执行完的任务数:0

线程池中线程数:2,队列中等待执行的任务数:0,已执行完的任务数:0

task1开始执行

线程池中线程数:3,队列中等待执行的任务数:0,已执行完的任务数:0

task2开始执行

线程池中线程数:4,队列中等待执行的任务数:0,已执行完的任务数:0

task3开始执行

线程池中线程数:5,队列中等待执行的任务数:0,已执行完的任务数:0

task4开始执行

线程池中线程数:5,队列中等待执行的任务数:1,已执行完的任务数:0

线程池中线程数:5,队列中等待执行的任务数:2,已执行完的任务数:0

线程池中线程数:5,队列中等待执行的任务数:3,已执行完的任务数:0

线程池中线程数:5,队列中等待执行的任务数:4,已执行完的任务数:0

线程池中线程数:5,队列中等待执行的任务数:5,已执行完的任务数:0

线程池中线程数:6,队列中等待执行的任务数:5,已执行完的任务数:0

task10开始执行

线程池中线程数:7,队列中等待执行的任务数:5,已执行完的任务数:0

task11开始执行

线程池中线程数:8,队列中等待执行的任务数:5,已执行完的任务数:0

task12开始执行

线程池中线程数:9,队列中等待执行的任务数:5,已执行完的任务数:0

task13开始执行

线程池中线程数:10,队列中等待执行的任务数:5,已执行完的任务数:0

task14开始执行

task5开始执行

task6开始执行

task7开始执行

task8开始执行

task9开始执行

由执行结果可以看出，当线程池中线程的数目大于5时，便将任务放入任务缓存队列里面，当任务缓存队列满了之后，便创建新的线程，直到线程数等于最大线程数10后，便不再创建新线程。

如果上面程序中，将for循环中改成执行20个任务，就会抛出任务拒绝异常了，因为最大线程10加上缓冲队列5，最多接受15个任务。

在java中，并不提倡直接使用ThreadPoolExecutor，而是使用Executors类中提供的几个静态方法来创建线程池，其内部也是调用ThreadPoolExecutor的构造方法，只不过参数已提前配置：

//corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，使用的SynchronousQueue。

Executors.newCachedThreadPool();

//corePoolSize和maximumPoolSize都设置为1，使用的LinkedBlockingQueue

Executors.newSingleThreadExecutor();

//corePoolSize和maximumPoolSize值是相等的，使用的LinkedBlockingQueue

Executors.newFixedThreadPool(int); 　

实际开发中，如能满足要求，尽量使用这三个静态方法。如ThreadPoolExecutor达不到要求，可自己继承ThreadPoolExecutor类进行重写。

最后要感谢这个优秀的平台，可以让我们相互交流，如果想进一步学习交流，可以加群460570824，希望大家可以一起学习进步！