JUC学习笔记 -- (10) 线程池

朴灿烈づ我的快乐病毒、 2022-05-13 16:38 242阅读 0赞

## 为什么用线程池 ##

1.  创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处理效率
    
    > 例如：
    > 
    > 记创建线程消耗时间T1，执行任务消耗时间T2，销毁线程消耗时间T3
    > 
    > 如果T1+T3>T2，那么是不是说开启一个线程来执行这个任务太不划算了！
    > 
    > 正好，线程池缓存线程，可用已有的闲置线程来执行新任务，避免了T1+T3带来的系统开销
2.  线程并发数量过多，抢占系统资源从而导致阻塞
    
    > 我们知道线程能共享系统资源，如果同时执行的线程过多，就有可能导致系统资源不足而产生阻塞的情况
    > 
    > 运用线程池能有效的控制线程最大并发数，避免以上的问题
3.  对线程进行一些简单的管理
    
    > 比如：延时执行、定时循环执行的策略等
    > 
    > 运用线程池都能进行很好的实现

## 线程池的总体架构 ##

![70][]

接口：Executor,CompletionService,ExecutorService，ScheduledExecutorService

抽象类：AbstractExecutorService

实现类：ExecutorCompletionService，ThreadPoolExecutor，ScheduledThreadPoolExecutor

## 线程池ThreadPoolExecutor ##

在Java中，线程池的概念是Executor这个接口，具体实现为ThreadPoolExecutor类，学习Java中的线程池，就可以直接学习他了

对线程池的配置，就是对ThreadPoolExecutor构造函数的参数的配置，既然这些参数这么重要，就来看看构造函数的各个参数吧

### ThreadPoolExecutor提供了四个构造函数 ###

//五个参数的构造函数
    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)

*  **int corePoolSize** => 该线程池中**核心线程数最大值**
    
    > **核心线程：**
    > 
    > 线程池新建线程的时候，如果当前线程总数小于corePoolSize，则新建的是核心线程，如果超过corePoolSize，则新建的是非核心线程
    > 
    > 核心线程默认情况下会一直存活在线程池中，即使这个核心线程啥也不干(闲置状态)。
    > 
    > 如果指定ThreadPoolExecutor的allowCoreThreadTimeOut这个属性为true，那么核心线程如果不干活(闲置状态)的话，超过一定时间(时长下面参数决定)，就会被销毁掉
 *  **int maximumPoolSize**
    
    > 该线程池中**线程总数最大值**
    > 
    > 线程总数 = 核心线程数 + 非核心线程数。
 *  **long keepAliveTime**
    
    > 该线程池中**非核心线程闲置超时时长**
    > 
    > 一个非核心线程，如果不干活(闲置状态)的时长超过这个参数所设定的时长，就会被销毁掉
    > 
    > 如果设置allowCoreThreadTimeOut = true，则会作用于核心线程
 *  **TimeUnit unit**
    
    > keepAliveTime的单位，TimeUnit是一个枚举类型，其包括：
    > 
    > 1.  NANOSECONDS ： 1微毫秒 = 1微秒 / 1000
    > 2.  MICROSECONDS ： 1微秒 = 1毫秒 / 1000
    > 3.  MILLISECONDS ： 1毫秒 = 1秒 /1000
    > 4.  SECONDS ： 秒
    > 5.  MINUTES ： 分
    > 6.  HOURS ： 小时
    > 7.  DAYS ： 天
 *  **BlockingQueue<Runnable> workQueue**
    
    > 该线程池中的任务队列：维护着等待执行的Runnable对象
    > 
    > 当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务
    > 
    > 常用的workQueue类型：
    > 
    > 1.  **SynchronousQueue：**这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX\_VALUE，即无限大
    > 2.  **LinkedBlockingQueue：**这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize
    > 3.  **ArrayBlockingQueue：**可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误
    > 4.  **DelayQueue：**队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务
 *  **ThreadFactory threadFactory**

线程工厂，用来创建线程。

*  **RejectedExecutionHandler handler** 线程饱和拒绝策略

> AbortPolicy:丢弃任务并抛出RejectedExecutionException
> 
> CallerRunsPolicy：只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。显然这样做不会真的丢弃任务，但是，任务提交线程的性能极有可能会急剧下降。
> 
> DiscardOldestPolicy：丢弃队列中最老的一个请求，也就是即将被执行的一个任务，并尝试再次提交当前任务。
> 
> DiscardPolicy：丢弃任务，不做任何处理。

新建一个线程池的时候，一般只用5个参数的构造函数。

### 向ThreadPoolExecutor添加任务 ###

那说了这么多，你可能有疑惑，我知道new一个ThreadPoolExecutor，大概知道各个参数是干嘛的，可是我new完了，怎么向线程池提交一个要执行的任务啊？

通过`ThreadPoolExecutor.execute(Runnable command)`方法向线程池内添加一个任务

或者使用`ThreadPoolExecutor.submit(Runnable command)`方法向线程池内添加一个任务，此方法可以获取返回值，而execute方法无法获取返回值。

### ThreadPoolExecutor的策略 ###

上面介绍参数的时候其实已经说到了ThreadPoolExecutor执行的策略，这里给总结一下，当一个任务被添加进线程池时：

1.  线程数量未达到corePoolSize，则新建一个线程(核心线程)执行任务
2.  线程数量达到了corePools，则将任务移入队列等待
3.  队列已满，新建线程(非核心线程)执行任务
4.  队列已满，总线程数又达到了maximumPoolSize，就会由上面RejectedExecutionHandler抛出异常

### **线程池的关闭** ###

ThreadPoolExecutor提供了两个方法，用于线程池的关闭，分别是shutdown()和shutdownNow()，其中：

shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务

shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务

## 常见四种线程池 ##

如果你不想自己写一个线程池，那么你可以从下面看看有没有符合你要求的(一般都够用了)，如果有，那么很好你直接用就行了，如果没有，那你就老老实实自己去写一个吧

Java通过Executors提供了四种线程池，这四种线程池都是直接或间接配置ThreadPoolExecutor的参数实现的，下面我都会贴出这四种线程池构造函数的源码，各位大佬们一看便知！

### newCachedThreadPool() ###

缓存线程池：

1.  线程数无限制
2.  有空闲线程则复用空闲线程，若无空闲线程则新建线程
3.  一定程度减少频繁创建/销毁线程，减少系统开销

创建方法：

`ExecutorService cachedThreadPool = Executors.newCachedThreadPool();`

源码：

public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); }

缓存线程池，缓存的线程默认存活60秒。线程的核心池corePoolSize大小为0，核心池最大为Integer.MAX\_VALUE,阻塞队列使用的是SynchronousQueue。是一个直接提交的阻塞队列，    他总会迫使线程池增加新的线程去执行新的任务。在没有任务执行时，当线程的空闲时间超过keepAliveTime（60秒），则工作线程将会终止被回收，当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销。如果同时又大量任务被提交，而且任务执行的时间不是特别快，那么线程池便会新增出等量的线程池处理任务，这很可能会很快耗尽系统的资源。

### newFixedThreadPool() ###

定长线程池：

1.  可控制线程最大并发数（同时执行的线程数）
2.  超出的线程会在队列中等待

创建方法：

//nThreads => 最大线程数即maximumPoolSize ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads); //threadFactory => 创建线程的方法 ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory);

源码：

public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }

固定大小的线程池，可以指定线程池的大小，该线程池corePoolSize和maximumPoolSize相等，阻塞队列使用的是LinkedBlockingQueue，大小为整数最大值。

该线程池中的线程数量始终不变，当有新任务提交时，线程池中有空闲线程则会立即执行，如果没有，则会暂存到阻塞队列。对于固定大小的线程池，不存在线程数量的变化。同时使用无界的LinkedBlockingQueue来存放执行的任务。当任务提交十分频繁的时候，LinkedBlockingQueue

迅速增大，存在着耗尽系统资源的问题。而且在线程池空闲时，即线程池中没有可运行任务时，它也不会释放工作线程，还会占用一定的系统资源，需要shutdown。

### newScheduledThreadPool() ###

定长线程池：

1.  支持定时及周期性任务执行。

创建方法：

//nThreads => 最大线程数即maximumPoolSize ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(int corePoolSize);

源码：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { return new ScheduledThreadPoolExecutor(corePoolSize); } //ScheduledThreadPoolExecutor(): public ScheduledThreadPoolExecutor(int corePoolSize) { super(corePoolSize, Integer.MAX_VALUE, DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS, new DelayedWorkQueue()); }

定时线程池，该线程池可用于周期性地去执行任务，通常用于周期性的同步数据。

## ##

### newSingleThreadExecutor() ###

单线程化的线程池：

1.  有且仅有一个工作线程执行任务
2.  所有任务按照指定顺序执行，即遵循队列的入队出队规则

创建方法：

`ExecutorService singleThreadPool = Executors.newSingleThreadPool();`

源码：

public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); }

单个线程线程池，只有一个线程的线程池，阻塞队列使用的是LinkedBlockingQueue,若有多余的任务提交到线程池中，则会被暂存到阻塞队列，待空闲时再去执行。按照先入先出的顺序执行任务。

### 使用实例: ###

newCachedThreadPool的实例:

public class TestThreadPool {
    
    	private static Runnable getThread(final int i){
    		return new Runnable() {
    			@Override
    			public void run() {
    				try {
    					Thread.sleep(200);
    				}catch (Exception e){
    
    				}
    				System.out.println(Thread.currentThread().getName()+":输出"+i);
    			}
    		};
    	}
    
    	public static void main(String[] args) {
    		ExecutorService pool = Executors.newCachedThreadPool();
    
    		for(int i=0;i<10;i++){
    			pool.submit(getThread(i));
    		}
    	}
    }

这里没用调用shutDown方法，这里可以发现过60秒之后，会自动释放资源。

执行结果:

![70 1][]

可以看出，newCachedThreadPool线程池是有多少任务就创建多少个线程去处理。

**newFixedThreadPool**的实例:

public class TestThreadPool {
    
    	private static Runnable getThread(final int i){
    		return new Runnable() {
    			@Override
    			public void run() {
    				try {
    					Thread.sleep(200);
    				}catch (Exception e){
    
    				}
    				System.out.println(Thread.currentThread().getName()+":输出"+i);
    			}
    		};
    	}
    
    	public static void main(String[] args) {
    		ExecutorService pool = Executors.newFixedThreadPool(5);
    
    		for(int i=0;i<10;i++){
    			pool.submit(getThread(i));
    		}
    		pool.shutdown();
    	}
    }

这里需要注意一点，newSingleThreadExecutor和newFixedThreadPool一样，在线程池中没有任务时可执行，也不会释放系统资源的，所以需要shudown。

执行结果:

![70 2][]

可以看出不管有多少任务，**newFixedThreadPool**最多之创建固定数量的线程去处理。

**newSingleThreadExecutor**实例:

public class TestThreadPool {
    
    	private static Runnable getThread(final int i){
    		return new Runnable() {
    			@Override
    			public void run() {
    				try {
    					Thread.sleep(200);
    				}catch (Exception e){
    
    				}
    				System.out.println(Thread.currentThread().getName()+":输出"+i);
    			}
    		};
    	}
    
    	public static void main(String[] args) {
    		ExecutorService pool = Executors.newSingleThreadExecutor();
    
    		for(int i=0;i<10;i++){
    			pool.submit(getThread(i));
    		}
    		pool.shutdown();
    	}
    }

和newFixedThreadPool一样，在线程池中没有任务时可执行，也不会释放系统资源的，所以需要shudown。

执行结果:

![70 3][]

可以看到，不管有多少任务，始终只有一个线程在执行。

**newScheduledThreadPool**的实例:

public class TestThreadPool {
    
    	private static Runnable getThread(final int i){
    		return new Runnable() {
    			@Override
    			public void run() {
    				try {
    					Thread.sleep(200);
    				}catch (Exception e){
    
    				}
    				System.out.println(Thread.currentThread().getName()+":输出"+i);
    			}
    		};
    	}
    
    	public static void main(String[] args) {
    		ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
    
    		for(int i=0;i<10;i++){
    			pool.schedule(getThread(i), 2, TimeUnit.SECONDS);
    		}
    		pool.shutdown();
    	}
    }

执行结果:

![70 4][]

所有线程延迟固定时间执行。

注:以上所有提交线程都可以是Callable，返回值是Future,可以获取到返回值。

## 最后杂谈                                                                                                     ##

### 如何选择线程池数量 ###

**线程池的大小决定着系统的性能，过大或者过小的线程池数量都无法发挥最优的系统性能。**

当然线程池的大小也不需要做的太过于精确，只需要避免过大和过小的情况。一般来说，确定线程池的大小需要考虑CPU的数量，内存大小，任务是计算密集型还是IO密集型等因素

**NCPU = CPU的数量**

**UCPU = 期望对CPU的使用率 0 ≤ UCPU ≤ 1**

**W/C = 等待时间与计算时间的比率**

**如果希望处理器达到理想的使用率，那么线程池的最优大小为：**

**线程池大小=NCPU \*UCPU(1+W/C)**

在Java中使用

int ncpus = Runtime.getRuntime().availableProcessors();

获取CPU的数量。

### **线程池工厂** ###

Executors的线程池如果不指定线程工厂会使用Executors中的DefaultThreadFactory,默认线程池工厂创建的线程都是非守护线程。

使用自定义的线程工厂可以做很多事情，比如可以跟踪线程池在何时创建了多少线程，也可以自定义线程名称和优先级。如果将

新建的线程都设置成守护线程，当主线程退出后，将会强制销毁线程池。

下面这个例子，记录了线程的创建，并将所有的线程设置成守护线程。

public class ThreadFactoryDemo {
        public static class MyThread implements Runnable{
    
            @Override
            public void run() {
                System.out.println(System.currentTimeMillis()+"Thread ID:"+Thread.currentThread().getId());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args){
        	MyThread task = new MyThread();
            ExecutorService es = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MICROSECONDS, new SynchronousQueue<Runnable>(), new ThreadFactory() {
                @Override
                public Thread newThread(Runnable r) {
                    Thread t = new Thread(r);
                    t.setDaemon(true);
                    System.out.println("创建线程"+t);
                    return  t;
                }
            });
            for (int i = 0;i<=4;i++){
               es.submit(task);
            }
        }
    }

### 扩展线程池 ###

ThreadPoolExecutor是可以拓展的，它提供了几个可以在子类中改写的方法：beforeExecute,afterExecute和terimated。

在执行任务的线程中将调用beforeExecute和afterExecute,这些方法中还可以添加日志，计时，监视或统计收集的功能，

还可以用来输出有用的调试信息，帮助系统诊断故障。

**线程池的正确使用**

以下阿里编码规范里面说的一段话：

线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors各个方法的弊端：  
1）newFixedThreadPool和newSingleThreadExecutor:  
  主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。  
2）newCachedThreadPool和newScheduledThreadPool:  
  主要问题是线程数最大数是Integer.MAX\_VALUE，可能会创建数量非常多的线程，甚至OOM。

## **手动创建线程池有几个注意点** ##

1.**任务独立。**如果任务依赖于其他任务，那么可能产生死锁。例如某个任务等待另一个任务的返回值或执行结果，那么除非线程池足够大，否则将发生线程饥饿死锁。

2.**合理配置阻塞时间过长的任务。**如果任务阻塞时间过长，那么即使不出现死锁，线程池的性能也会变得很糟糕。在Java并发包里可阻塞方法都同时定义了限时方式和不限时方式。例如

Thread.join,BlockingQueue.put,CountDownLatch.await等，如果任务超时，则标识任务失败，然后中止任务或者将任务放回队列以便随后执行，这样，无论任务的最终结果是否成功，这种办法都能够保证任务总能继续执行下去。

3.**设置合理的线程池大小。**只需要避免过大或者过小的情况即可，上文的公式**线程池大小=NCPU \*UCPU(1+W/C)**。

4.**选择合适的阻塞队列。**newFixedThreadPool和newSingleThreadExecutor都使用了无界的阻塞队列，无界阻塞队列会有消耗很大的内存，如果使用了有界阻塞队列，它会规避内存占用过大的问题，但是当任务填满有界阻塞队列，新的任务该怎么办？在使用有界队列是，需要选择合适的拒绝策略，队列的大小和线程池的大小必须一起调节。对于非常大的或者无界的线程池，可以使用SynchronousQueue来避免任务排队，以直接将任务从生产者提交到工作者线程。

[70]: /images/20220504/c4d24b7159754dc2aef5083cd99a39c4.png
[70 1]: /images/20220504/fd6566e030404b7a9ad9f0f142aa6703.png
[70 2]: /images/20220504/20af672809c14a8ca1f24ec452dc90d2.png
[70 3]: /images/20220504/ed3b805eac314746ad77e132f7ba164b.png
[70 4]: /images/20220504/0f50b6ef35784a1e9cfd410bfdab49d2.png