java - 线程池

 1. Executors:

一般不用这个，容易OOM. 它的底层：ThreadPoolExecutor.

 

 2.ThreadPoolExecutor:

1. corePoolSize、maximumPoolSize设置：

注：N为CPU总核数：

int poolSize = Runtime.getRuntime().availableProcessors() // 获取当前服务器的核数。

如果是CPU密集型应用，则线程池大小设置为N+1。

如果是IO密集型应用，则线程池大小设置为2N+1。

2. 工作顺序：

corePoolSize -> 任务队列 -> maximumPoolSize -> 拒绝策略

3. 线程的几种状态：

新建、就绪、运行、阻塞、死亡。

 

 

// Java线程池的完整构造函数
public ThreadPoolExecutor(
  int corePoolSize,  // 线程池长期维持的线程数，即使线程处于Idle状态，也不会回收。
  int maximumPoolSize, // 线程数的上限
  long keepAliveTime, TimeUnit unit, // 超过corePoolSize的线程的idle时长，
                                     // 超过这个时间，多余的线程会被回收。
  BlockingQueue<Runnable> workQueue, // 任务的排队队列
  ThreadFactory threadFactory, // 线程的产生方式
  RejectedExecutionHandler handler) // 拒绝策略


corePoolSize和maximumPoolSize设置不当会影响效率，甚至耗尽线程；
workQueue设置不当容易导致OOM；
handler设置不当会导致提交任务时抛出异常。

变量的含义：
private final BlockingQueue<Runnable> workQueue;              //任务缓存队列，用来存放等待执行的任务
private final ReentrantLock mainLock = new ReentrantLock();   //线程池的主要状态锁，对线程池状态（比如线程池大小
                                                              //、runState等）的改变都要使用这个锁
private final HashSet<Worker> workers = new HashSet<Worker>();  //用来存放工作集
 private volatile long  keepAliveTime;    //线程存活时间   
private volatile boolean allowCoreThreadTimeOut;   //是否允许为核心线程设置存活时间
private volatile int   corePoolSize;     //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）
private volatile int   maximumPoolSize;   //线程池最大能容忍的线程数
private volatile int   poolSize;       //线程池中当前的线程数
private volatile RejectedExecutionHandler handler; //任务拒绝策略
private volatile ThreadFactory threadFactory;   //线程工厂，用来创建线程
private int largestPoolSize;   //用来记录线程池中曾经出现过的最大线程数
private long completedTaskCount;   //用来记录已经执行完毕的任务个数

 

 execute(): 这个方法可以向线程池提交一个任务，交由线程池去执行。

submit(): 方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果。

 

 

 ThreadPoolExecutor参数：

1. 参数：

1. corePoolSize：

corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；

 

2. maximumPoolSize：

maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；

 

3. keepAliveTime：

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

 

4. unit

unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

TimeUnit.DAYS; //天

TimeUnit.HOURS; //小时

TimeUnit.MINUTES; //分钟

TimeUnit.SECONDS; //秒

TimeUnit.MILLISECONDS; //毫秒

TimeUnit.MICROSECONDS; //微妙

TimeUnit.NANOSECONDS; //纳秒

 

5. workQueue：

workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：

ArrayBlockingQueue;

LinkedBlockingQueue;

SynchronousQueue;

1、ArrayBlockingQueue：基于数组的先进先出，创建时必须指定大小，超出直接corePoolSize个任务，则加入到该队列中，只能加该queue设置的大小，其余的任务则创建线程，直到(corePoolSize＋新建线程)> maximumPoolSize。

2、LinkedBlockingQueue：基于链表的先进先出，无界队列。超出直接corePoolSize个任务，则加入到该队列中，直到资源耗尽。

3、synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。

 

6.threadFactory：

threadFactory：线程工厂，主要用来创建线程；

 

7.handler：

handler：表示当拒绝处理任务时的策略，有以下四种取值：

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

ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。

ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）。

ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务。

 

2. API:

线程池的关闭：

shutdown(): 此时线程池不能够接受新的任务，它会等待所有任务执行完毕；

shutdownNow(): 则线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务；

 

3. 阻塞队列的测试：

ArrayBlockingQueue;

LinkedBlockingQueue;

SynchronousQueue;

1、ArrayBlockingQueue：基于数组的先进先出，创建时必须指定大小，超出直接corePoolSize个任务，则加入到该队列中，只能加该queue设置的大小，其余的任务则创建线程，直到(corePoolSize＋新建线程) > maximumPoolSize。

2、LinkedBlockingQueue：基于链表的先进先出，无界队列。超出corePoolSize个任务，则加入到该队列中，直到资源耗尽。

3、synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。

 

 

 

 

 

 

4. 线程工厂的测试：

threadFactory：线程工厂，主要用来创建线程；

没有：就默认的：

有：自定义：

 

 

5. 拒绝策略的测试：

有默认、有设置、有自定义：

 

 

 

 

 

 

 

 

 

 

附：代码

package com.sy.synergism.base.dzip.web;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class ThreadPool {
    public static void main(String[] args) throws Exception {
        int corePoolSize = 2;
        int maximumPoolSize = 4;
        long keepAliveTime = 0L;
        TimeUnit unit = TimeUnit.MILLISECONDS;
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(3);
//        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(); // 可无限大
//        BlockingQueue<Runnable> workQueue = new SynchronousQueue<>(); 
        ThreadFactory threadFactory = new MyThreadFactory();
        RejectedExecutionHandler rejectedExecutionHandler = new MyRejectHandler();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue,
                threadFactory,
                rejectedExecutionHandler
        );

        for (int i = 1; i <= 10; i++) {
            MyTask myTask = new MyTask(String.valueOf(i));
            threadPoolExecutor.execute(myTask);
        }

    }

    static class MyThreadFactory implements ThreadFactory {
        private final AtomicInteger poolNumber = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "my-thread-" + poolNumber.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    }

    static class MyRejectHandler implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            doLog(r, executor);
        }

        private void doLog(Runnable r, ThreadPoolExecutor executor) {
            // 可做日志记录.
            System.err.println(r.toString() + " rejected");
        }
    }

    static class MyTask implements Runnable {
        private String name;

        public MyTask(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            try {
                System.out.println("ThreadName:" + Thread.currentThread().getName() + "; " + this.toString() + " is running");
                Thread.sleep(3000); // 任务执行慢一点
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "MyTask{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

}

参考：

https://www.cnblogs.com/CarpenterLee/p/9558026.html

https://blog.csdn.net/m0_37506254/article/details/90574038

https://www.jianshu.com/p/c41e942bcd64

https://www.jianshu.com/p/f030aa5d7a28

https://www.jianshu.com/p/0c9a74ef87ef