自己实现一个简单的线程池

手写一个简单的线程池

介绍

当使用多线程的时候频繁的创建销毁线程是比较耗费系统资源，这个时候就需要使用线程池来管理，减少资源的开销。在某站学习过后，决定自己也写一个简单的线程池，来加深印象。

线程池中肯定需要有一个等待队列，里面存入相关的任务。然后每次从里面取出任务执行，继续往队列里添加任务。在这个过程中可能任务处理的时间比较长，存或取这个过程就需要添加超时时间，不然一直会阻塞等待。

任务队列

基础属性

/**
 * 任务队列
 */
private final Deque<T> queue = new ArrayDeque<>();

/**
 * 锁
 */
private final ReentrantLock lock = new ReentrantLock();

/**
 * 队列为空 等待条件
 */
Condition takeCondition = lock.newCondition();
/**
 * 队列满了 等待条件
 */
Condition putCondition = lock.newCondition();

/**
 * 容量
 */
private final int capacity;

首先定义等待队列的一些基本属性

名称	作用
queue	用于存储任务的队列
lock	队列不是线程安全的，使用锁保证队列的操作是线程安全的
takeCondition	队列为空，取数据(任务)，就到里面去等待
putCondition	队列满了，存数据(任务)，进去等待
capacity	队列容量，可以存放多少任务

lock、takeCondition、putCondition就相当与生产消费者的实现。当队列里面为空的时候，取数据，就需要去takeCondition等待，并唤醒putCondition中的线程，往队里里面插入数据(任务)。当队列满了后，存数据，就到putCondition等待，并唤醒takeCondition中的线程，从队列里面取出数据(任务)。

take() 从队列里面获取任务

/**
 * 从队列里面取任务
 *
 * @return 返回任务
 */
public T take() {
    try {
        lock.lock();
        //如果队列为空就到takeCondition中等待
        while (queue.isEmpty()) {
            try {
                //等待
                takeCondition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //取出并移除队列的第一个任务
        T t = queue.removeFirst();
        //取值后，叫醒存任务线程
        putCondition.signal();
        return t;
    } finally {
        lock.unlock();
    }
}

由于queue中的操作是非线程安全的，所以需要加上lock锁。

当队列(queue)里面为空，就说明没有任务，这时候需要到takeCondition中等待。队列不为空就直接取队列的第一个元素(任务)，并且叫醒putCondition中的线程。

take(long timeout, TimeUnit unit) 带有超时时间的获取任务

/**
 * 有超时间的获取任务
 *
 * @param timeout
 * @param unit
 * @return
 */
public T take(long timeout, TimeUnit unit) {
    try {
        lock.lock();
        //转换成纳秒
        long nanos = unit.toNanos(timeout);
        //如果队列为空就到takeCondition中等待
        while (queue.isEmpty()) {
            try {
                //返回剩余时间 假如timeout为3s,当前线程在takeCondition等4s nanos=4-3=-1 超时等待 返回null
                if (nanos <= 0) {
                    return null;
                }
                //等待时间
                nanos = takeCondition.awaitNanos(nanos);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //取出并移除队列的第一个任务
        T t = queue.removeFirst();
        //取值后，叫醒putCondition线程
        putCondition.signal();
        return t;
    } finally {
        lock.unlock();
    }
}

在操作的时候，可能队列里的任务执行完了(queue没有任务了)，这时也没有任务往队列里面添加。如果没有等待时间的话，线程会一直阻塞在这里。设置了等待时间后，如果超过了等待时间那么就会返回null，线程也不会阻塞。

put(T task) 往队列里添加任务

/**
 * 将任务放入队列
 *
 * @param task 任务
 * @return 是否存入成功
 */
public boolean put(T task) {
    try {
        lock.lock();
        //队列满了
        while (queue.size() == capacity) {
            try {
                //等待
                putCondition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //放入队列
        queue.addLast(task);
        //唤醒 takeCondition中的线程
        takeCondition.signal();
        return true;
    } finally {
        lock.unlock();
    }
}

当队列长度等于容量(capacity),说明队列已经满了，这个时候就需要到putCondition等待。否则就往队列里面放入任务，并且叫醒takeCondition中的线程。

put(T task, long timeout, TimeUnit unit) 带超时时间的添加任务

/**
 * 将任务放入队列(带有超时时间的)
 *
 * @param task    任务
 * @param timeout 超时时间
 * @param unit    时间单位
 * @return 是否存入成功
 */
public boolean put(T task, long timeout, TimeUnit unit) {
    try {
        lock.lock();
        //转换为纳秒
        long nanos = unit.toNanos(timeout);
        //队列满了
        while (queue.size() == capacity) {
            try {
                //返回剩余时间
                if (nanos <= 0) {
                    return false;
                }
                //等待 并获取等待时间
                nanos = putCondition.awaitNanos(nanos);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //放入队列
        queue.addLast(task);
        //唤醒 takeCondition中的线程
        takeCondition.signal();
        return true;
    } finally {
        lock.unlock();
    }
}

可能队列里面的任务执行时间比较长，导致在添加任务的时候队列长度还是capacity，就会阻塞。所以加上了超时时间，达到了时间就结束

拒绝策略

定义一个接口，用于队列满后，将未入队的任务交给调用者处理

@FunctionalInterface
public interface RejectPolicy<T> {
    /**
     * 对外提供策略
     *
     * @param queue 队列
     * @param task  任务
     */
    void reject(BlockingQueue<T> queue, T task);
}

策略的处理

/**
 * 对策略进行处理
 *
 * @param rejectPolicy 策略
 * @param task         任务
 */
public void process(RejectPolicy<T> rejectPolicy, T task) {
    try {
        lock.lock();
        //队列满了
        if (queue.size() == capacity) {
            //执行对应策略
            rejectPolicy.reject(this, task);
        } else {
            //否则放入队列中
            queue.addLast(task);
            //唤醒获取队列的线程
            takeCondition.signal();
        }
    } finally {
        lock.unlock();
    }
}

队列满了就交给策略处理，没满就添加到队列，唤醒takeCondition中的线程，从队列取任务。

线程池

基础属性

/**队列*/
private BlockingQueue<Runnable> queue;

/**线程集合：存储正在执行的线程*/
private  HashSet<Worker> workers;
private  RejectPolicy<Runnable> rejectPolicy;
/**核心线程数*/
private  int coreSize;
/**超时时间*/
private long timeout;
/**时间类型*/
private TimeUnit unit;
/**任务对象*/
class Worker extends Thread {
    private Runnable task;

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

    @Override
    public void run() {
        //从队列里获取任务
        while (task != null || (task = queue.take(timeout, unit)) != null) {
            try {
                //执行任务
                task.run();
            } finally {
                task = null;
            }
        }
        synchronized (workers) {
            workers.remove(this);
        }
    }
}

名称	作用
queue	上面实现的等待线程队列
workers	存储正在执行的线程，也就是核心数
rejectPolicy	策略，当队列满了根据策略进行处理
coreSize	核心数，每实际启动任务的线程数量
timeout	超时时间
TimeUnit	时间类型
内部类Worker	继承了Thread，用于执行自己任务或从队列里面取出任务并执行

构造方法

/**
 * 初始化线程池
 *
 * @param coreSize     核心数(实际创建执行任务的线程数)
 * @param timeout      超时时间
 * @param unit         时间单位
 * @param capacity     等待队列容量
 * @param rejectPolicy 拒绝策略
 */
public ThreadPool(int coreSize, long timeout, TimeUnit unit, int capacity, RejectPolicy<Runnable> rejectPolicy) {
   this.queue = new BlockingQueue<>(capacity);
   workers = new HashSet<>(coreSize);
   this.coreSize = coreSize;
   this.timeout = timeout;
   this.unit = unit;
   this.rejectPolicy = rejectPolicy;
}

初始化核心数、超时时间、队列容量、拒绝策略等数据

执行任务

/**
 * 执行任务
 */
public void execute(Runnable task) {
    synchronized (workers) {
        //判断正在执行的任务是否<核心数
        if (workers.size() < coreSize) {
            //创建任务对象
            Worker worker = new Worker(task);
            //工作线程
            workers.add(worker);
            worker.start();
        } else {
            //交给策略
            queue.process(rejectPolicy, task);
        }
    }

}

由于HashSet中需要使用的操作不是线程安全的，所以需要用synchronized加锁。

当真在执行的任务数<核心数，这个时候就可以启动任务。start()调用Worker中的run()方法。我们拿出来再分析一遍。

public void run() {
    //从队列里获取任务
    while (task != null || (task = queue.take(timeout, unit)) != null) {
        try {
            //执行任务
            task.run();
        } finally {
            task = null;
        }
    }
    synchronized (workers) {
        workers.remove(this);
    }
}

如果任务为空(执行完毕就会为空)，那么就从队列里面取出任务执行，否则就执行自己初始化的任务。使用的是带超时时间的方式取出任务，如果不用带超时时间，在没有任务再入队情况下，那么队列中所有任务执行完毕后，就会阻塞(一直等待)。任务执行完毕后(队列为空)将task=null制空，从线程集合中移除当前任务。

测试代码

public static void main(String[] args) {
    //核心数为CPU核心数
    ThreadPool threadPool = new ThreadPool(Runtime.getRuntime().availableProcessors(), 1000,
            TimeUnit.MILLISECONDS, 10,
            ((queue, task) -> {
                //queue.put(task);
                queue.put(task, 1500, TimeUnit.SECONDS);
            }));
    for (int i = 0; i < 5; i++) {
        int j = i;
        threadPool.execute(() -> {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":" + j);
        });
    }
}

当你模拟写出一个简单的线程池后，你会对线程池中的一些概念有个基本的了解，再回过头去看JDK源码中Doug Lea实现的线程池会有一定的帮助。

相关源码(github)
相关源码(gitee)