一.四种常见的线程池详解

1. 线程池的返回值ExecutorService简介：

     ExecutorService是Java提供的用于管理线程池的类。该类的两个作用：控制线程数量和重用线程
   

2. 具体的4种常用的线程池实现如下：（返回值都是ExecutorService）

2.1 Executors.newCacheThreadPool()：可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务

示例代码：

package boss.bes.basedata.myutil.threadPool;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*** @version V1.0* @ClassName NewCachedThreadPoolTest* @PackageName boss.bes.basedata.myutil.threadPool* @Description: (用一句话描述该文件做什么)* @date: 2020/7/8 17:22* @author: lang*/
public class NewCachedThreadPoolTest {public static void main(String[] args) {ExecutorService cachedThreadPool = Executors.newCachedThreadPool();for (int i = 0; i < 10; i++) {try {// sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}cachedThreadPool.execute(new Runnable() {@Overridepublic void run() {// 打印正在执行的缓存线程信息System.out.println(Thread.currentThread().getName()+ "正在被执行");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});}cachedThreadPool.shutdown();//pool.shutdown();//平缓关闭，不允许新的线程加入，正在运行的都跑完即可关闭。// pool.shutdownNow();//暴力关闭。不允许新的线程加入，且直接停到正在进行的线程。}
}

输出结果：

pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行
pool-1-thread-1正在被执行

线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程

2.2 Executors.newFixedThreadPool(int n)：创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。
示例代码：

package boss.bes.basedata.myutil.threadPool;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*** @version V1.0* @ClassName newFixedThreadPoolTest* @PackageName boss.bes.basedata.myutil.threadPool* @Description: 创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程;*               定长线程池的大小最好根据系统资源进行设置* @date: 2020/7/9 10:17* @author: lang*/
public class newFixedThreadPoolTest {public static void main(String[] args) {ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);for (int i = 0; i < 10; i++) {fixedThreadPool.execute(new Runnable() {@Overridepublic void run() {try {System.out.println(Thread.currentThread().getName() + "正在执行");Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}});}}
}

输出结果：

pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行

因为线程池大小为3，每个任务输出打印结果后sleep 2秒，所以每两秒打印3个结果。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

2.3 Executors.newScheduledThreadPool(int n)：创建一个定长线程池，支持定时及周期性任务执行
延迟执行示例代码：

package boss.bes.basedata.myutil.threadPool;import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;/*** @version V1.0* @ClassName NewScheduledThreadPool* @PackageName boss.bes.basedata.myutil.threadPool* @Description: 创建一个定长线程池，支持定时及周期性任务执行* @date: 2020/7/9 10:44* @author: lang*/
public class NewScheduledThreadPool {public static void main(String[] args) {ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);//延迟1秒执行scheduledThreadPool.schedule(new Runnable() {@Overridepublic void run() {System.out.println("延迟1秒执行");}}, 1, TimeUnit.SECONDS);//延迟1秒后每3秒执行一次scheduledThreadPool.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {System.out.println("延迟1秒后每3秒执行一次");}}, 1, 3, TimeUnit.SECONDS);}}

输出结果：

延迟1秒后每3秒执行一次
延迟1秒后每3秒执行一次
…

2.4 Executors.newSingleThreadExecutor()：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
示例代码：

package boss.bes.basedata.myutil.threadPool;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*** @version V1.0* @ClassName NewSingleThreadExecutorTest* @PackageName boss.bes.basedata.myutil.threadPool* @Description: 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，*              保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。* @date: 2020/7/9 10:23* @author: lang*/
public class NewSingleThreadExecutorTest {public static void main(String[] args) {//创建一个单线程化的线程池ExecutorService singleThreadExcutor= Executors.newSingleThreadExecutor();for (int i=0;i<10;i++){final int index=i;singleThreadExcutor.execute(new Runnable() {@Overridepublic void run() {try {System.out.println(Thread.currentThread().getName()+"正在被执行，"+index);Thread.sleep(5000);}catch (InterruptedException e){e.printStackTrace();}}});}}
}

输出结果：

pool-1-thread-1正在被执行,打印的值是:0
pool-1-thread-1正在被执行,打印的值是:1
pool-1-thread-1正在被执行,打印的值是:2
pool-1-thread-1正在被执行,打印的值是:3
pool-1-thread-1正在被执行,打印的值是:4
pool-1-thread-1正在被执行,打印的值是:5
pool-1-thread-1正在被执行,打印的值是:6
pool-1-thread-1正在被执行,打印的值是:7
pool-1-thread-1正在被执行,打印的值是:8
pool-1-thread-1正在被执行,打印的值是:9

三、缓冲队列BlockingQueue和自定义线程池ThreadPoolExecutor

1. 缓冲队列BlockingQueue简介：

BlockingQueue是双缓冲队列。BlockingQueue内部使用两条队列，允许两个线程同时向队列一个存储，一个取出操作。在保证并发安全的同时，提高了队列的存取效率。

2. 常用的几种BlockingQueue：

ArrayBlockingQueue（int i）:规定大小的BlockingQueue，其构造必须指定大小。其所含的对象是FIFO顺序排序的。LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其构造时指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的。PriorityBlockingQueue（）或者（int i）:类似于LinkedBlockingQueue，但是其所含对象的排序不是FIFO，而是依据对象的自然顺序或者构造函数的Comparator决定。SynchronizedQueue（）:特殊的BlockingQueue，对其的操作必须是放和取交替完成。

3. 自定义线程池（ThreadPoolExecutor和BlockingQueue连用）

自定义线程池，可以用ThreadPoolExecutor类创建，它有多个构造方法来创建线程池。

常见的构造函数：ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue)

示例代码：

package boss.bes.basedata.myutil.threadPool;import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;/*** @version V1.0* @ClassName ThreadPoolExecutorTest* @PackageName boss.bes.basedata.myutil.threadPool* @Description: (用一句话描述该文件做什么)* @date: 2020/7/8 15:29* @author: lang*/
public class ThreadPoolExecutorTest {public static void main(String[]args){ThreadPoolExecutor pool=new ThreadPoolExecutor(1, 20, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(2));// 任务1pool.execute(() -> {try {Thread.sleep(3 * 1000);System.out.println("--helloWorld_001--  " + Thread.currentThread().getName()+1);} catch (InterruptedException e) {e.printStackTrace();}});//任务2pool.execute(() -> System.out.println("--helloWorld_002--  " + Thread.currentThread().getName()+2));pool.shutdown();}
}

四、总结

1、线程池流程：

1、判断核心线程池是否已满，没满则创建一个新的工作线程来执行任务。已满则。
2、判断任务队列是否已满，没满则将新提交的任务添加在工作队列，已满则。
3、判断整个线程池是否已满，没满则创建一个新的工作线程来执行任务，已满则执行饱和策略。

（1、判断线程池中当前线程数是否大于核心线程数，如果小于，在创建一个新的线程来执行任务，如果大于则
2、判断任务队列是否已满，没满则将新提交的任务添加在工作队列，已满则。
3、判断线程池中当前线程数是否大于最大线程数，如果小于，则创建一个新的线程来执行任务，如果大于，则执行饱和策略。）

2、如何配置线程池

CPU密集型任务
尽量使用较小的线程池，一般为CPU核心数+1。 因为CPU密集型任务使得CPU使用率很高，若开过多的线程数，会造成CPU过度切换。

IO密集型任务
可以使用稍大的线程池，一般为2*CPU核心数。 IO密集型任务CPU使用率并不高，因此可以让CPU在等待IO的时候有其他线程去处理别的任务，充分利用CPU时间。

混合型任务
可以将任务分成IO密集型和CPU密集型任务，然后分别用不同的线程池去处理。 只要分完之后两个任务的执行时间相差不大，那么就会比串行执行来的高效。
因为如果划分之后两个任务执行时间有数据级的差距，那么拆分没有意义。
因为先执行完的任务就要等后执行完的任务，最终的时间仍然取决于后执行完的任务，而且还要加上任务拆分与合并的开销，得不偿失。

3、java中提供的线程池

Executors类提供了4种不同的线程池：newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor

java线程池对比
1、newCachedThreadPool：用来创建一个可以无限扩大的线程池，适用于负载较轻的场景，执行短期异步任务。（可以使得任务快速得到执行，因为任务时间执行短，可以很快结束，也不会造成cpu过度切换）

2、newFixedThreadPool：创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于负载较重的场景，对当前线程数量进行限制。（保证线程数可控，不会造成线程过多，导致系统负载更为严重）

3、newSingleThreadExecutor：创建一个单线程的线程池，适用于需要保证顺序执行各个任务。

4、newScheduledThreadPool：适用于执行延时或者周期性任务。

4、execute()和submit()方法

1、execute()，执行一个任务，没有返回值。
2、submit()，提交一个线程任务，有返回值。
submit(Callable task)能获取到它的返回值，通过**future.get()**获取（阻塞直到任务执行完）。一般使用FutureTask+Callable配合使用（IntentService中有体现）。

submit(Runnable task, T result)能通过传入的载体result间接获得线程的返回值。
submit(Runnable task)则是没有返回值的，就算获取它的返回值也是null。

Future.get方法会使取结果的线程进入阻塞状态，知道线程执行完成之后，唤醒取结果的线程，然后返回结果。