package org.springframework.beans.factory.support; 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; public class TestPool { } class ThreadPool { //拒绝策略 private RejectPoliy<Runnable> rejectPoliy; //执行任务 public void execute(Runnable task) { //当前任务数没有超过coreSize时,直接交给worker对象执行, //如果任务数超过coreSize,加入任务队列暂存 synchronized (workers) { if (workers.size() < coreSize) { Worker worker = new Worker(task); workers.add(worker); worker.start(); } else { //taskQueue.put(task); //1死等 //2超时等待 //3放弃任务 //4抛出异常 //5调用者自己执行 taskQueue.tryPut(rejectPoliy, task); } } } //任务队列 private BlockingQueue<Runnable> taskQueue; //线程集合 private HashSet<Worker> workers = new HashSet<>(); //核心线程数 private int coreSize; //获取任务的超时时间 private long timeout; private TimeUnit timeUnit; public ThreadPool(int coreSize, long timeout, TimeUnit timeUnit, int queueCapcity, RejectPoliy<Runnable> rejectPoliy) { this.coreSize = coreSize; this.timeout = timeout; this.timeUnit = timeUnit; this.taskQueue = new BlockingQueue<>(queueCapcity); this.rejectPoliy = rejectPoliy; } 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) { try { task.run(); } catch (Exception e){ e.printStackTrace(); } finally { task = null; } } synchronized (workers) { workers.remove(this); } } } } class BlockingQueue<T> { //任务队列 private Deque<T> queue = new ArrayDeque<>(); //锁 private ReentrantLock lock = new ReentrantLock(); //生产者条件变量 private Condition fullWaitSet = lock.newCondition(); //消费者条件变量 private Condition emptyWaitSet = lock.newCondition(); //容量 private int capcity; public BlockingQueue(int capcity) { this.capcity = capcity; } //阻塞消费 public T take() { lock.lock(); try { while (queue.isEmpty()) { try { emptyWaitSet.await(); } catch (InterruptedException e) { e.printStackTrace(); } } T t = queue.removeFirst(); //消费之后,唤醒生产者 fullWaitSet.signal(); return t; } finally { lock.unlock(); } } //阻塞生产 public void put(T element) { lock.lock(); try { while (queue.size() == capcity) { try { fullWaitSet.await(); } catch (InterruptedException e) { e.printStackTrace(); } } queue.addLast(element); emptyWaitSet.signal(); } finally { lock.unlock(); } } //获取容量 public int size() { lock.lock(); try { return queue.size(); } finally { lock.unlock(); } } //带超时的阻塞添加 public boolean offer(T task, long timeout, TimeUnit timeUnit) { lock.lock(); try { long nanos = timeUnit.toNanos(timeout); while (queue.size() == capcity) { try { if(nanos <= 0) { return false; } nanos = fullWaitSet.awaitNanos(nanos); } catch (InterruptedException e) { e.printStackTrace(); } } queue.addLast(task); emptyWaitSet.signal(); return true; } finally { lock.unlock(); } } public void tryPut(RejectPoliy<T> rejectPoliy, T task) { lock.lock(); try { //判断队列是否已满 if(queue.size() == capcity) { rejectPoliy.reject(this, task); } else { //有空闲 queue.addLast(task); emptyWaitSet.signal(); } } finally { lock.unlock(); } } } @FunctionalInterface//拒绝策略 interface RejectPoliy<T> { void reject(BlockingQueue<T> queue, T task); }