Java并发编程：线程池的使用

为什么要使用线程池？

在平时开发中我们经常会使用到并发编程，我们可以一个一个的创建线程，也可以使用线程池创建。
如果我们所需要执行的任务量很小，我们可以一个个创建线程。
假设现在任务量巨大，你不能再使用单个创建线程了吧，所以就引出了线程池的使用。
线程池所创建的线程在执行完任务时，它不会被销毁，而是会继续去执行其他任务。

线程池的优点：

1. 降低消耗资源：通过重复利用已创建的线程降低线程的创建和销毁造成的消耗。
2. 提高响应速度：当任务到达时，可以不需要等待线程创建就能执行。
3. 提高线程的可管理性：线程时稀缺资源，如果无限制的创建，不仅会消耗资源，还会降低系统的稳定性，使用线程池统一分配，监控和调优。

Executor框架

Executor框架不仅包括了线程池的管理，还提供了线程工厂、队列以及拒绝策略等，让并发编程变得更加简单。
Executor是一个接口它只实现了一个execute方法。

ExecutorService接口继承于Executor。

抽象类AbstractExecutorService实现了ExecutorService接口。

ThreadPoolExcutor继承于抽象类AbstractExecutorService。

到这里，大家应该明白了ThreadPoolExecutor、AbstractExecutorService、ExecutorService和Executor几个之间的关系了。

ThreadPoolExecutor类

java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类，因此如果要透彻地了解Java中的线程池，必须先了解这个类。
该类中总共提供了四个构造方法：

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);
    ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

corePoolSize：核心池的大小。
maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程。
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。

默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；

unit：指的是keepAliveTime的单位。
workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。
threadFactory：线程工厂，主要用来创建线程。
handler：表示当拒绝处理任务时的策略，有以下四种取值：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

对于corePoolSize有个简单的例子：

假如有一个工厂，工厂里面有10个工人，每个工人同时只能做一件任务。

因此只要当10个工人中有工人是空闲的，来了任务就分配给空闲的工人做；

当10个工人都有任务在做时，如果还来了任务，就把任务进行排队等待；

如果说新任务数目增长的速度远远大于工人做任务的速度，那么此时工厂主管可能会想补救措施，比如重新招4个临时工人进来；

然后就将任务也分配给这4个临时工人做；

如果说着14个工人做任务的速度还是不够，此时工厂主管可能就要考虑不再接收新的任务或者抛弃前面的一些任务了。

当这14个工人当中有人空闲时，而新任务增长的速度又比较缓慢，工厂主管可能就考虑辞掉4个临时工了，只保持原来的10个工人，毕竟请额外的工人是要花钱的。
　　
　　这个例子中的corePoolSize就是10，而maximumPoolSize就是14（10+4）。

线程池的使用举例

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

class Number1 implements Runnable{

    @Override
    public void run() {
        for(int i = 100; i > 0; i--){
            if(i % 2 == 0){
                System.out.println("当前线程"+Thread.currentThread().getName()+"->"+i);
            }
        }
    }
}
class Number2 implements Runnable{

    @Override
    public void run() {
        for(int i = 100; i > 0; i--){
            if(i % 2 != 0){
                System.out.println("当前线程"+Thread.currentThread().getName()+"->"+i);
            }
        }
    }
}
public class ExecutorTest {
    public static void main(String[] args) {
        //newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数
        ExecutorService s = (ThreadPoolExecutor)Executors.newFixedThreadPool(5);

        Number1 n1 = new Number1();
        s.execute(n1);
        s.execute(new Number2());
        //关闭线程池
        s.shutdown();
    }


}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41