自定义线程池的逻辑图:
步骤如下:
1.首先定义BlockingQueue,实现生产者消费者模式
,设置获取、添加任务的方法
2.定义ThreadPool,设置核心数、池容量、阻塞队列对象、执行实体类等信息,实现execute方法
3、测试。
package 并发工具;
import lombok.extern.slf4j.Slf4j;
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;
@Slf4j(topic = "c.自定义线程池")
public class 自定义线程池 {
public static void main(String[] args) {
ThreadPool threadPool = new ThreadPool(2,1000,TimeUnit.MILLISECONDS, 10);
for (int i = 0; i < 5; i++) {
int j = i;
threadPool.execute(() -> {
log.debug("{}",j);
});
}
}
}
@FunctionalInterface //拒绝策略
interface RejectPolicy<T>{
void reject(BlockingQueue<T> queue,T task);
}
@Slf4j(topic = "c.ThreadPool")
class ThreadPool{
//任务队列
private BlockingQueue<Runnable> taskQueue;
//线程集合
private HashSet<Worker> workers = new HashSet<>();
//核心线程数
private int coreSize;
//获取任务超时时间
private long timeout;
private TimeUnit timeUnit;
private RejectPolicy<Runnable> rejectPolicy;
//执行任务
public void execute(Runnable task){
//当任务没有超过coreSize时,直接交给Worker对象执行
//如果任务数超过了CoreSize,加入任务队列暂存
synchronized (workers) {
if(workers.size() < coreSize){
Worker worker = new Worker(task);
log.debug("新增 worker {}",worker);
workers.add(worker);
worker.start();
} else{
log.debug("加入队列 {}",task);
taskQueue.put(task);
// 1) 死等
// 2) 带超时等待
// 3) 让调用者放弃任务执行
// 4) 让调用者抛出异常
// 5) 让调用者自己执行任务
//taskQueue.tryPut(rejectPolicy,task);
}
}
}
public ThreadPool(int coreSize, long timeout, TimeUnit timeUnit, int queueCapacity) {
this.coreSize = coreSize;
this.timeout = timeout;
this.timeUnit = timeUnit;
this.taskQueue = new BlockingQueue<>(queueCapacity);
}
public ThreadPool(int coreSize, long timeout, TimeUnit timeUnit, int queueCapacity, RejectPolicy<Runnable> rejectPolicy) {
this.coreSize = coreSize;
this.timeout = timeout;
this.timeUnit = timeUnit;
this.taskQueue = new BlockingQueue<>(queueCapacity);
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){
try{
log.debug("正在执行....{}",task);
task.run();
} catch (Exception e){
e.printStackTrace();
}finally {
task = null;
}
}
synchronized (workers){
log.debug("work 被移除 {}",this);
workers.remove(this);
}
}
}
}
//阻塞队列
@Slf4j(topic = "c.BlockingQueue")
class BlockingQueue<T> {
// 1. 任务队列,双向链表
private Deque<T> queue = new ArrayDeque<>();
// 2. 锁
private ReentrantLock lock = new ReentrantLock();
// 3. 生产者条件变量
private Condition fullWaitSet = lock.newCondition();
// 4. 消费者条件变量
private Condition emptyWaitSet = lock.newCondition();
// 5. 容量
private int capcity;
public BlockingQueue(int capcity) {
this.capcity = capcity;
}
// 带超时的阻塞获取
public T poll(long timeout, TimeUnit unit){
lock.lock();
try {
//将timeout统一转换为 纳秒
long nanos = unit.toNanos(timeout);
while(queue.isEmpty()){
try {
//返回的是剩余时间
if(nanos <= 0){
return null;
}
nanos = emptyWaitSet.awaitNanos(nanos);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
T t = queue.removeFirst();
//唤醒等待的线程
fullWaitSet.signal();
return t;
} finally {
lock.unlock();
}
}
// 阻塞获取
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 boolean offer(T task,long timeout,TimeUnit timeUnit){
lock.lock();
try {
long nanos = timeUnit.toNanos(timeout);
while(queue.size() == capcity){
try{
log.debug("等待加入任务队列 {} ....",task);
if(nanos <= 0){
return false;
}
nanos = fullWaitSet.awaitNanos(nanos);
} catch (Exception e){
e.printStackTrace();
}
}
log.debug("加入任务队列 {}",task);
queue.addLast(task);
emptyWaitSet.signal();
return true;
} finally {
lock.unlock();
}
}
//获取大小
public int size(){
lock.lock();
try{
return queue.size();
} finally {
lock.unlock();
}
}
public void tryPut(RejectPolicy<T> rejectPolicy, T task) {
lock.lock();
try{
//判断队列是否满
if(queue.size() == capcity){
rejectPolicy.reject(this,task);
} else {
log.debug("加入任务队列 {}",task);
queue.addLast(task);
emptyWaitSet.signal();
}
} finally {
lock.unlock();
}
}
}
输出:
17:37:56.216 [main] DEBUG c.ThreadPool - 新增 worker Thread[Thread-0,5,main]
17:37:56.223 [main] DEBUG c.ThreadPool - 新增 worker Thread[Thread-1,5,main]
17:37:56.223 [Thread-0] DEBUG c.ThreadPool - 正在执行....并发工具.自定义线程池$$Lambda$1/2036368507@2231df33
17:37:56.223 [main] DEBUG c.ThreadPool - 加入队列 并发工具.自定义线程池$$Lambda$1/2036368507@1f89ab83
17:37:56.224 [Thread-0] DEBUG c.自定义线程池 - 0
17:37:56.224 [Thread-1] DEBUG c.ThreadPool - 正在执行....并发工具.自定义线程池$$Lambda$1/2036368507@166b3cbc
17:37:56.224 [main] DEBUG c.ThreadPool - 加入队列 并发工具.自定义线程池$$Lambda$1/2036368507@e73f9ac
17:37:56.224 [Thread-0] DEBUG c.ThreadPool - 正在执行....并发工具.自定义线程池$$Lambda$1/2036368507@1f89ab83
17:37:56.224 [Thread-1] DEBUG c.自定义线程池 - 1
17:37:56.224 [main] DEBUG c.ThreadPool - 加入队列 并发工具.自定义线程池$$Lambda$1/2036368507@61064425
17:37:56.225 [Thread-0] DEBUG c.自定义线程池 - 2
17:37:56.225 [Thread-1] DEBUG c.ThreadPool - 正在执行....并发工具.自定义线程池$$Lambda$1/2036368507@e73f9ac
17:37:56.225 [Thread-0] DEBUG c.ThreadPool - 正在执行....并发工具.自定义线程池$$Lambda$1/2036368507@61064425
17:37:56.225 [Thread-1] DEBUG c.自定义线程池 - 3
17:37:56.225 [Thread-0] DEBUG c.自定义线程池 - 4