1、自定义线程池
内容来自于黑马程序员
package com.cky.leedecode;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashSet;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* @ClassName TestPool
* @Description TODO
* @Author lukcy
* @Date 2024/9/22 15:38
* @Version 1.0
*/
public class TestPool {
public static void main(String[] args) {
ThreadPool threadPool = new ThreadPool(1, 1000, TimeUnit.MILLISECONDS, 1, (queue,task)->{
//死等
// queue.put(task);
//带超时等待
// queue.offer(task, 1500, TimeUnit.MILLISECONDS);
//让调用者放弃任务执行
// System.out.println("放弃：" + task);
//让调用者抛出异常
// throw new RuntimeException("任务执行失败" + task);
//让调用者自己执行任务
task.run();
});
for (int i = 0; i <3; i++) {
int j = i;
threadPool.execute(()->{
try {
System.out.println(Thread.currentThread().toString() + "执行任务：" + j);
Thread.sleep(1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
}
}
@FunctionalInterface //拒绝策略
interface RejectPolicy<T>{
void reject(BlockingQueue<T> queue,T task);
}
//任务队列
class BlockingQueue<T>{
//阻塞队列，存放任务
private Deque<T> queue = new ArrayDeque<>();
//队列的最大容量
private int capacity;
//锁
private ReentrantLock lock = new ReentrantLock();
//生产者条件变量
private Condition fullWaitSet = lock.newCondition();
//消费者条件变量
private Condition emptyWaitSet = lock.newCondition();
//构造方法
public BlockingQueue(int capacity) {
this.capacity = capacity;
}
//超时阻塞获取
public T poll(long timeout, TimeUnit unit){
lock.lock();
//将时间转换为纳秒
long nanoTime = unit.toNanos(timeout);
try{
while(queue.size() == 0){
try {
//等待超时依旧没有获取，返回null
if(nanoTime <= 0){
return null;
}
//该方法返回的是剩余时间
nanoTime = emptyWaitSet.awaitNanos(nanoTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
T t = queue.pollFirst();
fullWaitSet.signal();
return t;
}finally {
lock.unlock();
}
}
//阻塞获取
public T take(){
lock.lock();
try{
while(queue.size() == 0){
try {
emptyWaitSet.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
T t = queue.pollFirst();
fullWaitSet.signal();
return t;
}finally {
lock.unlock();
}
}
//阻塞添加
public void put(T t){
lock.lock();
try{
while (queue.size() == capacity){
try {
System.out.println(Thread.currentThread().toString() + "等待加入任务队列:" + t.toString());
fullWaitSet.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().toString() + "加入任务队列:" + t.toString());
queue.addLast(t);
emptyWaitSet.signal();
}finally {
lock.unlock();
}
}
//超时阻塞添加
public boolean offer(T t,long timeout,TimeUnit timeUnit){
lock.lock();
try{
long nanoTime = timeUnit.toNanos(timeout);
while (queue.size() == capacity){
try {
if(nanoTime <= 0){
System.out.println("等待超时，加入失败：" + t);
return false;
}
System.out.println(Thread.currentThread().toString() + "等待加入任务队列:" + t.toString());
nanoTime = fullWaitSet.awaitNanos(nanoTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().toString() + "加入任务队列:" + t.toString());
queue.addLast(t);
emptyWaitSet.signal();
return true;
}finally {
lock.unlock();
}
}
public int size(){
lock.lock();
try{
return queue.size();
}finally{
lock.unlock();
}
}
//从形参接收拒绝策略的put方法
public void tryPut(RejectPolicy<T> rejectPolicy,T task){
lock.lock();
try{
if(queue.size() == capacity){
rejectPolicy.reject(this,task);
}else{
System.out.println("加入任务队列：" + task);
queue.addLast(task);
emptyWaitSet.signal();
}
}finally {
lock.unlock();
}
}
}
//线程池
class ThreadPool{
//阻塞队列
BlockingQueue<Runnable> taskQue;
//线程集合
HashSet<Worker> workers = new HashSet<>();
//拒绝策略
private RejectPolicy<Runnable> rejectPolicy;
//构造方法
public ThreadPool(int coreSize,long timeout,TimeUnit timeUnit,int queueCapacity,RejectPolicy<Runnable> rejectPolicy){
this.coreSize = coreSize;
this.timeout = timeout;
this.timeUnit = timeUnit;
this.rejectPolicy = rejectPolicy;
taskQue = new BlockingQueue<Runnable>(queueCapacity);
}
//线程数
private int coreSize;
//任务超时时间
private long timeout;
//时间单元
private TimeUnit timeUnit;
//线程池的执行方法
public void execute(Runnable task){
//当线程数大于等于coreSize的时候，将任务放入阻塞队列
//当线程数小于coreSize的时候，新建一个Worker放入workers
//注意workers类不是线程安全的， 需要加锁
synchronized (workers){
if(workers.size() >= coreSize){
// taskQue.put(task);
//死等
//带超时等待
//让调用者放弃执行任务
//让调用者抛出异常
//让调用者自己执行任务
taskQue.tryPut(rejectPolicy,task);
}else {
Worker worker = new Worker(task);
System.out.println(Thread.currentThread().toString() + "新增worker:" + worker + ",task:" + task);
workers.add(worker);
worker.start();
}
}
}
//工作类
class Worker extends Thread{
private Runnable task;
public Worker(Runnable task){
this.task = task;
}
@Override
public void run() {
//巧妙的判断
while(task != null || (task = taskQue.poll(timeout,timeUnit)) != null){
try{
System.out.println(Thread.currentThread().toString() + "正在执行:" + task);
task.run();
}catch (Exception e){
}finally {
task = null;
}
}
synchronized (workers){
System.out.println(Thread.currentThread().toString() + "worker被移除:" + this.toString());
workers.remove(this);
}
}
}
}
2、问题
1.为什么要用线程池？线程池的优势是什么？
线程池主要的工作是控制运行的线程数量，处理过程中将任务放进队列里，然后在线程创建后启动这些任务，如果线程数量超过了最大数量的线程排队等候，等其他线程执行完毕，再从队列里取出任务来执行。
主要特点：线程复用、控制最大并发数、管理线程
（1）降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的损耗；
（2）提高响应速度，当任务到达时，任务可以不需要等到线程创建就可以执行；
（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控。
线程池是一个管理线程的池子。由于创建和关闭线程需要花费时间，如果为每一个任务都创建一个线程，非常消耗资源。使用线程池可以避免增加创建和销毁线程的资源消耗，提高响应速度，且能重复利用线程。在使用线程池后，创建线程就变成了从线程池中获取空闲线程，关闭线程变成了向线程池归还线程。
2.线程池的几个重要参数介绍？
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
corePoolSize: 线程池中核心线程的数量
maximumPoolSize ：线程池中最大线程数量
keepAliveTime：非核心线程的存活时间
TimeUnit unit：存活时间单位
workQueue：任务队列
threadFactory：线程工厂，用于创建线程，一般用默认的即可
handler：拒绝策略，当队列满了并且工作线程大于等于线程池的最大线程数
3.线程池的执行流程？
（1）在创建线程池后，等待提交过来的任务请求；
（2）当调用execute()方法添加一个请求任务时，线程池会做如下判断：
如果正在运行的线程数量小于corePoolSize，那么马上创建核心线程运行这个任务；
如果正在运行的线程数量大于或者等于corePoolSize，那么将这个任务放入任务队列中；
如果任务队列满了且正在运行的线程数量小于maximumPoolSize(最大线程数)，那么创建一个非核心线程立刻运行这个任务；
如果任务队列满了且正在运行的线程数量大于或等于maximumPoolSize，线程池会执行拒绝策略；
（3）当一个线程完成任务时，会在队列中取下一个任务来执行；
（4）当一个线程无事可做超过一定时间时，线程池会停掉。
4.拒绝策略？
等待的任务队列满了，容纳不下新任务，同时线程池中的最大线程数也达到了，无法创建新的非核心线程去处理任务，此时需要拒绝策略。
AbortPolicy：抛出 RejectedExecutionException异常阻止系统正常进行；
CallerRunsPolicy：将任务回退到调用者，由调用线程处理该任务。
DiscardOldestPolicy：丢弃任务队列中等待最久的任务，将当前任务放入任务队列中；
DiscardPolicy：直接丢弃任务，不处理也不抛出异常；
5.单一的、固定数、可变的三中创建线程的方法，你在工作中用到过哪个？
//ExecutorService threadPool = Executors.newFixedThreadPool(5);//一池5个处理线程
//ExecutorService threadPool = Executors.newFixedThreadPool(1);//一池1个线程
ExecutorService threadPool = Executors.newCachedThreadPool();//一池N个线程
一般不适用这三种方法，阿里巴巴Java开发手册中说过，线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
说明：Executors返回的线程池对象的弊端如下：
（1）FixedThreadPool和SingleThreadPool:
允许请求的队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM；
（2）CacheThreadPool和ScheduledThreadPool:
允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM；
6.如何合理配置线程池？
分两种，CPU密集和IO密集
线程池究竟设置多大要看你的线程池执行的什么任务了，有CPU密集型和IO密集型，任务类型不同，分配的线程池大小不同。
（1）CPU密集
CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。
CPU密集任务只有在真正的多核CPU上才可能得到加速(通过多线程)，而在单核CPU上，无论你开几个模拟的多线程，该任务都不可能得到加速，因为CPU总的运算能力就那些。
CPU密集型任务应配置尽可能小的线程，一般公式是：配置CPU核数+1个线程的线程池，
（2）IO密集
IO密集型，即该任务需要大量的IO，即大量的阻塞。在单线程上运行IO密集型的任务会导致浪费大量的CPU运算能力浪费在等待。所以在IO密集型任务中使用多线程可以大大的加速程序运行，即时在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。
方法一：可以使用较大的线程池，一般CPU核心数 * 2
IO密集型CPU使用率不高，可以让CPU等待IO的时候处理别的任务，充分利用cpu时间
方法二：线程等待时间所占比例越高，需要越多线程。线程CPU时间所占比例越高，需要越少线程。
下面举个例子：
比如平均每个线程CPU运行时间为0.5s，而线程等待时间（非CPU运行时间，比如IO）为1.5s，CPU核心数为8，那么根据上面这个公式估算得到：((0.5+1.5)/0.5)8=32。这个公式进一步转化为：
最佳线程数目 = （线程等待时间与线程CPU时间之比 + 1） CPU数目
