Java线程池

简介

线程池的概念：

    线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

线程池的工作机制

    2.1 在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。

多线程运行时间，系统不断的启动和关闭新线程，成本非常高，会过渡消耗系统资源，以及过渡切换线程的危险，从而可能导致系统资源的崩溃。这时，线程池就是最好的选择了。

四种常见的线程池详解

1，重要的类：

ExecutorService类：线程池的返回值，是Java提供的用于管理线程池的类。该类的两个作用：控制线程数量和重用线程
ScheduledExecutorService ：能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。

ThreadPoolExecutor：ExecutorService的默认实现。 ScheduledThreadPoolExecutor
：继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。

2，四种线程池

1,newCachedThreadPoo 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
2,newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
3,newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
4,newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

3，各种线程池的适应场景
newCachedThreadPool：用来创建一个可以无限扩大的线程池，适用于服务器负载较轻，执行很多短期异步任务。
newFixedThreadPool：创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于可以预测线程数量的业务中，或者服务器负载较重，对当前线程数量进行限制。
newSingleThreadExecutor：创建一个单线程的线程池，适用于需要保证顺序执行各个任务，并且在任意时间点，不会有多个线程是活动的场景。
newScheduledThreadPool：可以延时启动，定时启动的线程池，适用于需要多个后台线程执行周期任务的场景。

newWorkStealingPool：创建一个拥有多个任务队列的线程池，可以减少连接数，创建当前可用cpu数量的线程来并行执行，适用于大耗时的操作，可以并行来执行

4，Demo
①， Executors.newCacheThreadPool()：

package com.example.demo.tet;


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

/**
 * 描述: 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。
 * 此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
 *
 * @author yanpenglei
 * @create 2017-10-12 11:13
 **/
public class TestNewCachedThreadPool {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 1; i <= 10; i++) {
            final int index = i;
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    System.out.println("执行：" + index + "，线程名称：" + threadName);
                    try {
                        Thread.sleep(index * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

执行结果：

执行：1，线程名称：pool-1-thread-1 执行：2，线程名称：pool-1-thread-2
执行：7，线程名称：pool-1-thread-7 执行：8，线程名称：pool-1-thread-8
执行：3，线程名称：pool-1-thread-3 执行：6，线程名称：pool-1-thread-6
执行：4，线程名称：pool-1-thread-4 执行：5，线程名称：pool-1-thread-5
执行：9，线程名称：pool-1-thread-9 执行：10，线程名称：pool-1-thread-10

②， Executors.newFixedThreadPool(int n)：

package com.example.demo.tet;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewFixedThreadPool {

    public static void main(String[] args) {
        // 创建一个可重用固定个数的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        // 打印正在执行的缓存线程信息
                        System.out.println(Thread.currentThread().getName()
                                + "正在被执行");
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

执行结果：因为线程池大小为3，每个任务输出打印结果后sleep 2秒，所以每两秒打印3个结果

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

③，Executors.newScheduledThreadPool(int n)：

package com.example.demo.tet;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
 * @Author yyq
 * @Date 2020/9/7 20:05
 * @Version 1.0
 */
public class NewScheduledThreadPool {

    public static void main(String[] args) {
        //创建一个定长线程池，支持定时及周期性任务执行——延迟执行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延迟1秒后每3秒执行一次
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("延迟1秒后每3秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);

    }
}

④，Executors.newSingleThreadExecutor()：

package com.example.demo.tet;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @Author yyq
 * @Date 2020/9/7 20:08
 * @Version 1.0
 */
public class NewSingleThreadExecutor {
    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(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

5，缓冲队列BlockingQueue和自定义线程池ThreadPoolExecutor

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

常用的几种BlockingQueue：

ArrayBlockingQueue（int i）:规定大小的BlockingQueue，其构造必须指定大小。其所含的对象是FIFO顺序排序的。

LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其构造时指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的。

PriorityBlockingQueue（）或者（int i）:类似于LinkedBlockingQueue，但是其所含对象的排序不是FIFO，而是依据对象的自然顺序或者构造函数的Comparator决定。

SynchronizedQueue（）:特殊的BlockingQueue，对其的操作必须是放和取交替完成。

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

自定义线程池，可以用ThreadPoolExecutor类创建，它有多个构造方法来创建线程池。常见的构造函数：ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
BlockingQueue workQueue)

demo：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ZiDingYiThreadPoolExecutor {
    
public static    class TempThread implements Runnable {
          
             @Override
             public void run() {
                 // 打印正在执行的缓存线程信息
                 System.out.println(Thread.currentThread().getName() + "正在被执行");
                 try {
                     // sleep一秒保证3个任务在分别在3个线程上执行
                    Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         
         }
    
    
public static void main(String[] args) {
                 // 创建数组型缓冲等待队列
                 BlockingQueue<Runnable> bq = new ArrayBlockingQueue<Runnable>(10);
                 // ThreadPoolExecutor:创建自定义线程池，池中保存的线程数为3，允许最大的线程数为6
                 ThreadPoolExecutor tpe = new ThreadPoolExecutor(3, 6, 50, TimeUnit.MILLISECONDS, bq);
                 // 创建3个任务
                 Runnable t1 = new TempThread();
                 Runnable t2 = new TempThread();
                 Runnable t3 = new TempThread();
                 Runnable t4 = new TempThread();
                 Runnable t5 = new TempThread();
                 Runnable t6 = new TempThread();
                 // 3个任务在分别在3个线程上执行
                 tpe.execute(t1);
                 tpe.execute(t2);
                 tpe.execute(t3);
                  tpe.execute(t4);
                  tpe.execute(t5);
                  tpe.execute(t6);
         
                 // 关闭自定义线程池
                 tpe.shutdown();
             }
}

6，四种线程池拒绝策略

简单demo

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2,
0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());
threadPoolExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());

①，ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

这是线程池默认的拒绝策略，在任务不能再提交的时候，抛出异常，及时反馈程序运行状态。如果是比较关键的业务，推荐使用此拒绝策略，这样子在系统不能承载更大的并发量的时候，能够及时的通过异常发现。

②，ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。如果线程队列已满，则后续提交的任务都会被丢弃，且是静默丢弃。

使用此策略，可能会使我们无法发现系统的异常状态。建议是一些无关紧要的业务采用此策略。例如，本人的博客网站统计阅读量就是采用的这种拒绝策略

③，ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务。

此拒绝策略，是一种喜新厌旧的拒绝策略。是否要采用此种拒绝策略，还得根据实际业务是否允许丢弃老任务来认真衡量。

④，ThreadPoolExecutor.CallerRunsPolicy：，如果任务被拒绝了，则由调用线程（提交任务的线程）直接执行此任务，

  public static void main(String[] args) {
        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);
        ThreadFactory factory = r -> new Thread(r, "test-thread-pool");
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5,
                0L, TimeUnit.SECONDS, queue, factory, new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + ":执行任务");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }

main:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务
main:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务
test-thread-pool:执行任务

通过结果可以看到，主线程main也执行了任务，这正说明了此拒绝策略由调用线程（提交任务的线程）直接执行被丢弃的任务的。

本片主要作为笔记，其中有部分摘抄自https://blog.csdn.net/achuo/article/details/80623893