线程池的基本实现

 阻塞队列

package org.butupi.pool;

import lombok.extern.slf4j.Slf4j;
import org.butupi.rejectPolicy.RejectPolicy;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 任务队列
 * @param <T>
 */
@Slf4j(topic = "TaskQueue")
public 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 capacity;

    /**
     * 构造器
     * @param capacity
     */
    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    /**
     * 阻塞获取任务
     * @return
     */
    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();
        }
    }

    /**
     * 超时阻塞获取任务
     * @return
     */
    public T poll(long timeout, TimeUnit unit){
        lock.lock();
        try {
            long nanos = unit.toNanos(timeout);// 将timeout超时时间统一转换为纳秒
            // 没有任务
            while (queue.isEmpty()){
                try {
                    // 限时等待
//                    emptyWaitSet.await();
                    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();
        }
    }

    /**
     * 阻塞添加任务
     * @param task
     */
    public void put(T task){
        lock.lock();
        try {
            // 队列满，等待
            while (queue.size() == capacity){
                // 阻塞等待
                try {
                    log.info("等待加入任务队列：{}", task);
                    fullWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 添加到队列尾
            log.info("加入任务队列：{}", task);
            queue.addLast(task);
            // 唤醒拿任务的线程
            emptyWaitSet.signal();
        }finally {
            lock.unlock();
        }
    }

    /**
     * 向阻塞队列添加任务,超时等待
     * @param task
     * @param timeout
     * @param timeUnit
     * @return
     */
    public boolean offer(T task,long timeout, TimeUnit timeUnit){
        lock.lock();
        try {
            long nanos = timeUnit.toNanos(timeout);
            // 队列满，等待
            while (queue.size() == capacity){
                // 阻塞等待
                try {

                    log.info("等待加入任务队列：{}", task);
                    if (nanos <= 0){
                        return false;
                    }
                    nanos = fullWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 添加到队列尾
            log.info("加入任务队列：{}", task);
            queue.addLast(task);
            // 唤醒拿任务的线程
            emptyWaitSet.signal();
            return true;
        }finally {
            lock.unlock();
        }
    }

    /**
     * 获取任务的数量
     * @return
     */
    public int size(){
        lock.lock();
        try {
            return queue.size();
        }finally {
            lock.unlock();
        }
    }


    /**
     * 添加任务，的方法（拒绝策略
     * @param rejectPolicy
     * @param task
     */
    public void tryPut(RejectPolicy<T> rejectPolicy, T task) {
        lock.lock();
        try {
            // 判断队列是否满
            if (queue.size() == capacity){
                // 拒绝策略
                rejectPolicy.reject(this,task);
            }else {
                // 队列空闲
                // 添加到队列尾
                log.info("加入任务队列：{}", task);
                queue.addLast(task);
                // 唤醒拿任务的线程
                emptyWaitSet.signal();
            }
        }finally {
            lock.unlock();
        }
    }
}

拒绝策略

package org.butupi.rejectPolicy;

import org.butupi.pool.BlockingQueue;

@FunctionalInterface
public interface RejectPolicy<T> {
    void reject(BlockingQueue<T> queue,T task);
}

线程池

package org.butupi.pool;

import javafx.concurrent.Worker;
import lombok.extern.slf4j.Slf4j;
import org.butupi.rejectPolicy.RejectPolicy;

import java.util.HashSet;
import java.util.concurrent.TimeUnit;

@Slf4j(topic = "c.ThreadPool")
public 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;


    /**
     * 线程池构造器
     *
     * @param coreSize
     * @param timeout
     * @param timeUnit
     * @param 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;
    }

    /**
     * 执行任务
     *
     * @param task
     */
    public void execute(Runnable task) {
        synchronized (workers) {
            // 当任务数没有超过核心线程数时交给worker对象执行
            if (workers.size() < coreSize) {
                // 创建新的线程，把它添加到线程池workers中
                Worker worker = new Worker(task);
                log.info("新增 worker：{},任务：{}", worker, task);

                workers.add(worker);
                worker.start();
            } else {
                // 超过coreSize时，添加到任务队列
                // 1死等
//                taskQueue.put(task);
                // 2超时等待
                // 3放弃任务
                // 4主线程抛异常
                // 5调用者自己执行
                // 策略模式
                taskQueue.tryPut(rejectPolicy,task);

            }
        }

    }

    /**
     * 包装线程，有Worker包装Thread
     */
    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.info("正在执行。。。{}", task);
                    task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }

            // 移除此线程
            synchronized (workers) {
                log.info("worker:{} 被移除", this);
                workers.remove(this);
            }
        }
    }
}

测试类

（含拒绝策略的lambda表达式）

package org.butupi.pool;

import com.sun.org.apache.bcel.internal.generic.ATHROW;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

@Slf4j(topic = "c.TestPool")
public class Main {
    public static void main(String[] args) {
        ThreadPool threadPool = new ThreadPool(2, 1000, TimeUnit.MILLISECONDS, 10,
                // 死等
//                BlockingQueue::put
                // 超时等待
//                ((queue, task) -> queue.offer(task,1000,TimeUnit.MILLISECONDS))
                // 放弃任务执行
//                (queue,task)->log.info("放弃任务{}执行",task)
                // 抛异常
//                ((queue, task) -> {throw new RuntimeException("任务执行失败 "+task);})
                // 调用者自己执行
                (queue, task) -> task.run()
        );
        for (int i = 0; i < 15; i++) {
            int j = i;
            threadPool.execute(() -> {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.info("{}", j);
            });
        }
    }
}