java自定义实现阻塞队列和线程池

不多BB，直接上代码。

阻塞队列：

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;

    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    // 超时阻塞获取任务
    public T pull(long timeout, TimeUnit unit){
        lock.lock();
        try{
            // 将超时时间统一转换为纳秒
            long nanos = unit.toNanos(timeout);
            // 取任务的时候，如果为空则需要等待
            while(queue.isEmpty()){
                // 超时的情况直接返回null
                if(nanos <= 0){
                    return null;
                }
                // 返回的是剩余的时间
                nanos = emptyWaitSet.awaitNanos(nanos);
            }
            T t = queue.removeFirst();
            // 唤醒放入的线程
            fullWaitSet.signal();
            return t;
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

    // 阻塞获取任务
    public T take(){
        // 加锁
        lock.lock();
        try{
            // 取任务的时候，如果为空则需要等待
            while(queue.isEmpty()){
                emptyWaitSet.await();
            }
            T t = queue.removeFirst();
            fullWaitSet.signal();
            return t;
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

    // 带超时时间的阻塞添加任务
    public boolean offer(T task, long timeout, TimeUnit timeUnit){
        lock.lock();
        try{
            long nanos = timeUnit.toNanos(timeout);
            // 添加任务时，如果队列已满则需要等待
            while(queue.size()==capacity ){
                System.out.println(task.toString() + " 等待加入任务队列" );
                if(nanos<=0){
                    return false;
                }
                nanos = fullWaitSet.awaitNanos(nanos);
            }
            queue.addLast(task);
            System.out.println("任务【" + task.toString() +  "】加入队列 " );
            emptyWaitSet.signal();
            return true;
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

    // 阻塞添加任务
    public void put(T task){
        lock.lock();
        try{
            while(queue.size()==capacity){
                System.out.println(task.toString() + " 等待加入任务队列" );
                fullWaitSet.await();
            }
            queue.addLast(task);
            System.out.println("任务【" + task.toString() +  "】加入队列 " );
            emptyWaitSet.signal();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } 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()==capacity){
                rejectPolicy.reject(this,task);
            }else{ // 有空闲
                queue.addLast(task);
                System.out.println("任务【" + task.toString() +  "】加入队列 " );
                emptyWaitSet.signal();
            }

        }finally {
            lock.unlock();
        }
    }
}

线程池：

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;

    // 线程池传入任务的方法
    public void execute(Runnable task){
        // 当任务数没有超过coreSize,直接交给worker对象执行
        // 如果任务数超过coreSize时，加入任务队列
        // 因为集合workers为共享变量，所以此处也需要加锁
        synchronized (workers){
            if(workers.size() < coreSize){
                Worker worker = new Worker(task);
                System.out.println("新增worker " + worker.toString() + " 任务 " + task.toString());
                workers.add(worker);
                worker.start();
            }else{
                taskQueue.tryPut(rejectPolicy, task);
            }
        }
    }

    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;

        private Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            // 执行任务
            // 1.当task不为空，则执行任务
            // 2.当task执行完毕，接着去任务队列中获取并执行
            // 此处使用了短路逻辑
            while(task !=null || (task = taskQueue.pull(timeout, timeUnit)) !=null ){
                try{
                    System.out.println("正在执行: " + task.toString());
                    task.run();
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    task = null;
                }
            }
            // 超时获取时，如果未获取到任务，则结束该线程
            synchronized (workers){
                System.out.println("worker 移除:" + this.toString());
                workers.remove(this);
            }
        }
    }
}`

拒绝策略：

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

测试：

public class MyThreadPoolTest {
    public static void main(String[] args) {
        // 定义线程池，传入参数为线程数，超时时间(当获取任务时间超过改时间时，结果等待)
        // 时间单位， 队列容量，拒绝策略，此处出lambda表达式，因为我们实现的拒绝策略只有一个接口，所以可以这样写
        ThreadPool pool = new ThreadPool(5, 1000,
                TimeUnit.MICROSECONDS, 100,(queue, task)->{
            // 1.死等
            // queue.put(task);
            // 2.带超时的等待
             queue.offer(task, 1500, TimeUnit.MILLISECONDS);
            // 3.让调用者放弃任务执行
            // System.out.println("队列已满放弃等待");
            // 4.抛出异常
//            throw new RuntimeException("任务执行失败，队列已满" + task);
            // 5.自己执行
            // task.run();
        });

        // 给线程池提交任务，循环3次，任务为打印，执行每次失眠一秒
        for (int i = 0; i < 3; i++) {
            int id = i+1;
            pool.execute(()->{
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().toString()+ " " + id);
            });
        }

    }
}

实际使用时可以把线程池定义为final static 类型，保证jvm中只存在一个；或者使用单例模式创建线程池。