并发编程学习7—解密线程池

并发工具有线程池，J.U.C.包（第八章），第三方工具类（第九章）

1. 自定义线程池 △△

阻塞队列，为了平衡生产者和消费者（线程池）速度差异的组件。

@Slf4j(topic = "x.PoolTest1")  
public class PoolTest1 {  
    public static void main(String[] args) {  
        ThreadPool threadPool = new ThreadPool(1,1000,  
                TimeUnit.MILLISECONDS, 1, (queue, task)->{  
            // 1) 队列满了就死等  
            // queue.put(task);  
            // 2) 带超时的等待  
            // queue.offer(task, 500, TimeUnit.MILLISECONDS);  
            // 3) 让调用者线程（main）放弃这个任务  
            //log.debug("放弃{}", task);  
            // 4) 让主线程抛出异常,和上面区别是让后面任务不执行了  
            // throw new RuntimeException("任务执行失败" + task);  
            // 5) 让调用者自己执行任务  
            task.run();  
        });  
        for (int i = 0; i < 4; i++) {  
            int j =i;  
            threadPool.execute( ()->{  
                try {  
                    Thread.sleep(1500L);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                log.debug("{}", j);  
            });  
        }  
    }  
}  
  
@Slf4j(topic = "x.ThreadPool")  
// 阻塞队列  
class BlockingQueue<T>{  
    // 1. 任务队列  
    private Deque<T> deque = new ArrayDeque<>();  
    // 2. 线程池中多个线程要从队首获得任务，只能一个线程获取，队尾也需要保护  
    private ReentrantLock lock = new ReentrantLock();  
    // 3. 生产者（main等）的条件变量（队列有限制的，不能无限往里生产）  
    //    消费者（Pool）的条件变量 （队列里无元素，得阻塞等待）  
    private Condition fullWaitSet = lock.newCondition();  
    private Condition emptyWaitSet = lock.newCondition();  
    // 4. 容量上限  
    private int capcity;  
  
    public BlockingQueue(int capcity) {  
        this.capcity = capcity;  
    }  
  
    // Pool带超时的去阻塞获取  
    public T poll(long timeout, TimeUnit unit){  
        lock.lock();  
        try {  
            // 将timeout统一转为纳秒  
            Long nanos = unit.toNanos(timeout);  
            while (deque.isEmpty()){  
                try {  
                    // 等待了一段时间，没有就放弃这个等待  
                    if(nanos <= 0){                     // 已经超时了  
                        return null;  
                    }  
                    // 返回的剩余时间  
                    nanos = emptyWaitSet.awaitNanos(nanos);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            // 队列不空，await会唤醒，再进循环while不成立，运行下面代码  
            T t = deque.removeFirst();  
            fullWaitSet.signal();  
            return t;  
        } finally {  
            lock.unlock();  
        }  
    }  
  
    // Pool去阻塞获取  
    public T take(){  
        lock.lock();  
        try {  
            // 队列为空时，不能获取了，进入emptyWait等待；  
            while (deque.isEmpty()){  
                try {  
                    emptyWaitSet.await();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            // 队列不空，await会唤醒，再进循环while不成立，运行下面代码 △△
            T t = deque.removeFirst(); 
            // 队列不空，可以叫醒生产者继续生产了 
            fullWaitSet.signal();  
            return t;  
        } finally {  
            lock.unlock();  
        }  
    }  
  
    // 阻塞添加  
    public void put(T task){  
        lock.lock();  
        try {  
            // 队列满了，不能添加  
            while (deque.size() == capcity){  
                try {  
                    log.debug("等待加入任务队列 {}...", task);  
                    fullWaitSet.await();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            log.debug("加入任务队列 {}", task);  
            // 有别的线程取走了，就会唤醒fullWaitSet(signal)，循环判断不等于cap，就运行下面代码  
            // 新的任务添加到队尾  
            deque.addLast(task);  
            emptyWaitSet.signal();  
        } finally {  
            lock.unlock();  
        }  
    }  
  
    // 带超时时间的阻塞添加  
    public boolean offer(T task, long timeout, TimeUnit unit){  
        lock.lock();  
        try {  
            long nanos = unit.toNanos(timeout);  
            while (deque.size() == capcity){  
                try {  
                    log.debug("等待加入任务队列 {}...", task);  
                    if(nanos <= 0){  
                        return false;  
                    }  
                    nanos = fullWaitSet.awaitNanos(nanos);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            log.debug("加入任务队列 {}", task);  
            // 有别的线程取走了，就会唤醒fullWaitSet(signal)，循环判断不等于cap，就运行下面代码  
            // 新的任务添加到队尾  
            deque.addLast(task);  
            emptyWaitSet.signal();  
            return true;        } finally {  
            lock.unlock();  
        }  
    }  
  
    // 获取队列大小  
    public int size(){  
        lock.lock();  
        try {  
            return deque.size();  
        } finally {  
            lock.unlock();  
        }  
    }  
  
    public void tryPut(RejectPolicy<T> rejectPolicy, T task) {  
        lock.lock();  
        try {  
            // 判断队列是否已满  
            if (deque.size() == capcity){  
                rejectPolicy.reject(this, task);  
            } else {   // 队列有空闲  
                log.debug("加入任务队列 {}", task);  
                deque.addLast(task);  
                emptyWaitSet.signal();  
            }  
        } finally {  
            lock.unlock();  
        }  
    }  
}  
  
// 拒绝策略  
@FunctionalInterface  
interface RejectPolicy<T> {  
    void reject(BlockingQueue<T> queue, T task);  
}  
  
  
// 线程池  
@Slf4j(topic = "x.ThreadPool")  
class ThreadPool{  
    // 任务队列 (任务可以抽象成Runnable)  
    private BlockingQueue<Runnable> taskQueue;  
    // 线程集合  (光Thread信息有限，现在我包装成一个worker类)  
    private HashSet<Worker> workers = new HashSet<>();  
    // 核心线程数  
    private int coreSize;  
    // 没有任务，运行也是浪费，设置一个获取任务的超时时间  
    private long timeout;  
    // 时间单位  
    private TimeUnit timeUnit;  
    // 拒绝策略
    private RejectPolicy<Runnable> rejectPolicy;  
  
    // 执行任务  
    public void execute(Runnable task){  
        // 当任务数没有超过核心数时, 把任务交给线程对象Worker来执行任务  
        // 如果超过了, 就要把它交给任务队列暂存起来，阻塞起来。  
        synchronized (workers) {  
            // 保证workers的线程安全  
            if(workers.size() < coreSize){  
                Worker worker = new Worker(task);  
                log.debug("新增worker {}, {}", worker, task);  
                workers.add(worker);  
                worker.start();  
            }else {  
                log.debug("加入任务队列 {}", task);  
                // 策略模式，抽象成接口 【RejectPolicy】  
                // 1) 队列满了就死等  
                // taskQueue.put(task);  
                // 2) 带超时的等待  
                // 3) 让调用者线程（main）放弃这个任务  
                // 4) 让主线程抛出异常  
                // 5) 让调用者自己执行任务  
                /**  
                 * 封装到taskQueue，因为里面有reenlock,把接口里的逻辑放在内部完成，可以保证线程安全  
                 */  
                taskQueue.tryPut(rejectPolicy, task);  
            }  
        }  
    }  
  
    // Alt+Ins 快速类基本添加方法  
    public ThreadPool(int coreSize, long timeout, TimeUnit timeUnit, int queueCapcity, RejectPolicy<Runnable> rejectPolicy) {  
        this.coreSize = coreSize;  
        this.timeout = timeout;  
        this.timeUnit = timeUnit;  
        this.taskQueue = new BlockingQueue<>(queueCapcity);  
        this.rejectPolicy = rejectPolicy;  
    }  
  
    class Worker extends Thread{  
        private Runnable task;  
  
        public Worker(Runnable task) {  
            this.task = task;  
        }  
  
        @Override  
        public void run() {  
            // 执行任务  
            // 1) 当task 不为空，执行任务  
            // 2) 当task执行完毕，再接着从任务队列获取任务并执行  
            //while (task != null || (task = taskQueue.take() ) != null){  
            while (task != null || (task = taskQueue.poll(timeout,timeUnit) ) != null){  
                try {  
                    log.debug("正在执行... {}", task);  
                    task.run();  
                } catch (Exception e){  
                    e.printStackTrace();  
                } finally {  
                    task = null;  
                }  
            }  
            synchronized (workers){  
                log.debug("worker被移除 {}", this);  
                workers.remove(this);  
            }  
        }  
    }  
}

2. JDK提供的线程池实现

2. 1 线程池状态

从数字上比较，TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING

不用两个int存的原因：
这些信息存储在一个原子变量 ctl 中，目的是将线程池状态与线程个数合二为一，这样就可以用一次 cas 原子操作进行赋值。

// c 为旧值， ctlOf 返回结果为新值
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))));

// rs 为高 3 位代表线程池状态， wc 为低 29 位代表线程个数，ctl 是合并它们
private static int ctlOf(int rs, int wc) { return rs | wc; }  // 位或

2. 2 构造方法

public ThreadPoolExecutor(int corePoolSize,
						int maximumPoolSize,
						long keepAliveTime,
						TimeUnit unit,
						BlockingQueue<Runnable> workQueue,
						ThreadFactory threadFactory,
						RejectedExecutionHandler handler)

• corePoolSize 核心线程数目 (最多保留的线程数，没有超时时间)
• maximumPoolSize 最大线程数目（核心线程数+救急线程数）
• keepAliveTime 生存时间 - 针对救急线程
• unit 时间单位 - 针对救急线程
• workQueue 阻塞队列
• threadFactory 线程工厂 - 创建线程池，并可以为线程创建时起个好名字
• handler 拒绝策略

2. 2. 1 工作方式：

1. 线程池中刚开始没有线程，当一个任务提交给线程池后，线程池会创建一个新线程来执行任务。

2. 当线程数达到 corePoolSize 并没有线程空闲，这时再加入任务，新加的任务会被加入workQueue 队列排队，直到有空闲的线程。

3. 如果队列选择了有界队列，那么任务超过了队列大小时，(JDK还不会去拒绝)会创建 maximumPoolSize - corePoolSize 数目的线程来救急。

4. 如果线程到达 maximumPoolSize 仍然有新任务这时会执行拒绝策略。拒绝策略 jdk 提供了 4 种实现，其它著名框架也提供了实现：

AbortPolicy 让调用者抛出 RejectedExecutionException 异常，这是默认策略。
CallerRunsPolicy 让调用者运行任务。
DiscardPolicy 放弃本次任务。
DiscardOldestPolicy 放弃队列中最早的任务，本任务取而代之。
Dubbo 的实现，在抛出 RejectedExecutionException 异常之前会记录日志，并 dump 线程栈信息，方便定位问题。
Netty 的实现，是创建一个新线程来执行任务。
ActiveMQ 的实现，带超时等待（60s）尝试放入队列，类似我们之前自定义的拒绝策略。
PinPoint 的实现，它使用了一个拒绝策略链，会逐一尝试策略链中每种拒绝策略。

5. 当高峰过去后，超过corePoolSize 的救急线程如果一段时间没有任务做，需要结束节省资源，这个时间由keepAliveTime 和 unit 来控制。
   ![[uTools_1689060889014.png]]
   根据这个构造方法，JDK Executors 类中提供了众多工厂方法来创建各种用途的线程池。

2. 3 newFixedThreadPool 固定大小

工厂方法
![[uTools_1689061281362.png]]
评价

2. 4 newCachedThreadPool 带缓冲的线程池

![[uTools_1689061389170.png]]

特点
核心线程数是 0，最大线程数是 Integer.MAX_VALUE，救急线程的空闲生存时间是 60s，意味着 1. 全部都是救急线程（60s 后可以回收）。 2. 救急线程可以无限创建。
队列采用了 SynchronousQueue 实现特点是，它没有容量，没有线程来取是放不进去的（一手交钱、一手交货）。

![[uTools_1689061881327.png]]
评价：整个线程池表现为线程数会根据任务量不断增长，没有上限，当任务执行完毕，空闲 1分钟后释放线程。 适合任务数比较密集，但每个任务执行时间较短的情况。

2. 5 newSingleThreadExecutor

![[uTools_1689062045838.png]]
使用场景：
希望多个任务排队执行（实现串行效果）。线程数固定为 1，任务数多于 1 时，会放入无界队列排队。任务执行完毕，这唯一的线程也不会被释放。

区别：

• 自己创建一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施，而线程池还会新建一个线程，保证池的正常工作。

• Executors.newSingleThreadExecutor() 线程个数始终为1，不能修改。

FinalizableDelegatedExecutorService 应用的是装饰器模式，只对外暴露了 ExecutorService 接口。（是代理模式，代理模式有限制访问权限的功能）

• 此不能调用 ThreadPoolExecutor 中特有的方法。

Executors.newFixedThreadPool(1) 初始时为1，以后还可以修改。

对外暴露的是 ThreadPoolExecutor 对象，可以强转后调用 setCorePoolSize 等方法进行修改。

2. 6 提交任务

// 1. 执行任务
void execute(Runnable command);

// 2. 提交任务 task，用返回值 Future 获得任务执行结果 (Callable和Runnable相比有返回结果)
<T> Future<T> submit(Callable<T> task);

// 3. 提交 tasks 中所有任务
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
	throws InterruptedException;

// 4. 提交 tasks 中所有任务，带超时时间
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
	throws InterruptedException;

// 5. 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
	throws InterruptedException, ExecutionException;

// 6. 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消，带超时时间
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
	throws InterruptedException, ExecutionException, TimeoutException;

第二个 submit：返回结果的执行。（ future就是用保护性暂停模式接受另一个线程的返回结果。）
==注意里面 Callable的接口是有@FunctionalInterface修饰的但方法接口，可以使用lambda表达式写法，放在Callable上面 Alt + Enter快速转为Lambda写法。 ==
![[uTools_1689062947050.png]]
第3，5个：

@Slf4j(topic = "x.PoolTest1")  
public class submitTest2 {  
    public static void main(String[] args) throws ExecutionException, InterruptedException {  
        ExecutorService pool = Executors.newFixedThreadPool(2);  
  
        // Ctrl + Alt + M 快速抓成一个方法  
        //method2(pool);   // 2.  
  
        // 3. 有返回值，并且是一个集合  
        //method3(pool);  
  
        // 5. 返回最先得到结果的任务。 此时只执行力2，只花了0.5，其他的任务都取消了  
        // 但当上面固定大小线程池为1时，只会执行1, 1执行完了已经有结果了，不会去线程池找2，3  
         String res = pool.invokeAny(Arrays.asList(  
                () -> {  
                    log.debug("begin 1");  
                    Thread.sleep(1000);  
                    return "1";  
                },  
                () -> {  
                    log.debug("begin 2");  
                    Thread.sleep(500);  
                    return "2";  
                },  
                () -> {  
                    log.debug("begin 3");  
                    Thread.sleep(2000);  
                    return "3";  
                }  
        ));  
         log.debug("{}", res);  
  
    }  
  
    private static void method3(ExecutorService pool) throws InterruptedException {  
        List<Future<String>> futures = pool.invokeAll(Arrays.asList(  
                () -> {  
                    log.debug("begin");  
                    Thread.sleep(1000);  
                    return "1";  
                },  
                () -> {  
                    log.debug("begin");  
                    Thread.sleep(500);  
                    return "2";  
                },  
                () -> {  
                    log.debug("begin");  
                    Thread.sleep(2000);  
                    return "3";  
                }  
        ));  
        // 只有两个线程位置，第三个现在阻塞队列里。  
        // 等了0.5s,第二个执行完，第三个开始，所以总共3个花费了2.5s  
        // Rerun: Ctrl + F5        
        futures.forEach( f-> {  
            try {  
                log.debug("{}", f.get());  
            } catch (InterruptedException | ExecutionException e) {  
                e.printStackTrace();  
            }  
        });  
    }  
  
    private static void method2(ExecutorService pool) throws InterruptedException, ExecutionException {  
        Future<String> future = pool.submit(() -> {  
            log.debug("running");  
            Thread.sleep(1000);  
            return "OK";  
        });  
        log.debug("{}", future.get());  
    }  
}

2. 7 关闭线程池

1. shutdown
   线程池状态变为 SHUTDOWN

只是不会接收新任务
但已提交任务（正在执行和在任务队列里的）会执行完
此方法也不会阻塞调用线程的执行 (只会打断空闲线程)

2. shutdownNow
   线程池状态变为 STOP

不会接收新任务
会将队列中的任务返回，也是不执行的
并用 interrupt 的方式中断正在执行的任务

3. 其它方法