Java 多线程（八）——实现简单线程池

1 简单线程池

package com.jtzen9;

import java.util.LinkedList;

public class ThreadPool extends ThreadGroup {
    // 线程池是否关闭
    private boolean isClosed = false;
    // 表示工作队列，即提交给线程池的任务
    private LinkedList<Runnable> workQueue;
    // 表示线程池ID
    private static int threadPoolID;
    // 表示工作线程ID
    private int threadID;

    // poolSize指定线程池中的工作线程数目
    public ThreadPool(int poolSize) {
        super("ThreadPool-" + (threadPoolID++));
        setDaemon(true);
        workQueue = new LinkedList<Runnable>();  //创建工作队列
        for (int i=0; i<poolSize; i++)
            new WorkThread().start();  //创建并启动工作线程
    }

    /**
     * 向工作队列中加入一个新任务，由工作线程去执行该任务
     * @param task 加入的任务
     */
    public synchronized void execute(Runnable task) {
        if (isClosed) { // 线程池被关则抛出IllegalStateException异常
            throw new IllegalStateException();
        }
        if (task != null) {
            workQueue.add(task);
            notify();  // 唤醒正在getTask()方法中等待任务的工作线程
        }
    }

    /**
     * 从工作队列中取出一个任务，工作线程会调用此方法
     * @return
     * @throws InterruptedException
     */
    protected synchronized Runnable getTask()throws InterruptedException{
        while (workQueue.size() == 0) {
            if (isClosed) return null;
            wait();  //如果工作队列中没有任务，就等待任务
        }
        return workQueue.removeFirst();
    }

    /**
     * 关闭线程池
     */
    public synchronized void close() {
        if (!isClosed) {
            isClosed = true;
            workQueue.clear(); //清空工作队列
            interrupt();  //中断所有的工作线程，该方法继承自ThreadGroup类
        }
    }

    /**
     * 等待工作线程把所有任务执行完
     */
    public void join() {
        synchronized (this) {
            isClosed = true;
            notifyAll();  // 唤醒还在getTask()方法中等待任务的工作线程
        }

        Thread[] threads = new Thread[activeCount()];
        // enumerate()方法继承自ThreadGroup类，获得线程组中当前所有活着的工作线程
        int count = enumerate(threads);
        // 等待所有工作线程运行结束
        for (int i=0; i < count; i++) {
            try {
                // 等待工作线程运行结束
                threads[i].join();
            }catch(InterruptedException ex) { }
        }
    }

    /**
     * 内部类：工作线程
     */
    private class WorkThread extends Thread {
        public WorkThread() {
            // 加入到当前ThreadPool线程组中
            super(ThreadPool.this,"WorkThread-" + (threadID++));
        }

        public void run() {
            // isInterrupted()方法继承自Thread类，判断线程是否被中断
            while (!isInterrupted()) {
                Runnable task = null;
                try {
                    // 得到任务
                    task = getTask();
                }catch (InterruptedException ex){}

                // 如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程
                if (task == null)
                    return;

                try {
                    // 运行任务，捕获异常
                    task.run();
                } catch (Throwable t) {
                    t.printStackTrace();
                }
            }
        }
    }
}

2 测试

package com.jtzen9;

public class Main {
    public static void main(String[] args){
        // 创建线程池，该线程池有3个线程
        ThreadPool threadPool = new ThreadPool(3);
        // 创建5个工作任务，并交给线程池执行
        for (int i = 0; i < 5; i++) {
            threadPool.execute(createTask(i));
        }
        threadPool.join();
        threadPool.close();
    }

    /**  定义了一个简单的任务(打印ID)   */
    private static Runnable createTask(final int taskID) {
        return new Runnable() {
            public void run() {
                System.out.println("Task " + taskID + ": start");
                try {
                    Thread.sleep(500);  //增加执行一个任务的时间
                } catch (InterruptedException ex) { }
                System.out.println("Task " + taskID + ": end");
            }
        };
    }
}

3 输出

Task 0: start
Task 1: start
Task 2: start
Task 1: end
Task 0: end
Task 3: start
Task 4: start
Task 2: end
Task 3: end
Task 4: end