自己动手实现JAVA线程池

　　线程池，只听过，没见过也没用过。项目中因为牵扯到图片下载，所以借此机会来学习一下这方面的知识。

 

　　线程池的知识，我在这里就不进行总结了，网上是很多的，我这边文章主要就是总结一下自己写的线程池代码。

　　首先先说一下我的思路。线程池嘛，肯定是一个对多个线程引用的一个对象，有添加任务、激活线程去完成任务、关闭等功能。工作线程需要保证完成一项任务之后不结束，那么需要run方法中是一个类似于死循环的循环，循环的出口是线程池关闭的标志。但是当线程池中没有任务时，工作线程不能让这个循环进去下去，这样实际上是增加的CPU负担，所以需要使工作线程在没有工作时处于等待状态(wait)。工作线程每次接收到任务时，就需要做指定的任务，因此需要一个任务接口，工作线程接收到任务则调用这个接口中的指定方法即可。

　　

　　线程池类

package my.java.threadpool;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class ThreadPool
{
    private final int MAX_COUNT = 3;
    private WorkThread worker[] = new WorkThread[MAX_COUNT];

    private List<Task> taskList = Collections.synchronizedList(new LinkedList<Task>());

    private boolean isRun = false;

    private int length = 0;
    private boolean isShowLog;

    private static ThreadPool httpClient = new ThreadPool();

    private ThreadPool()
    {
        isRun = true;
        for (int i = 0; i < MAX_COUNT; i++)
        {
            worker[i] = new WorkThread(this, "工作线程" + i + "号");

            worker[i].start();
        }
    }

    public static ThreadPool getInstance()
    {
        return httpClient;
    }

    /**
     * 在线程池中添加新的任务
     * 
     * @param object
     *            操作线程可能需要的数据
     */
    public void addToThreadPool(Task run)
    {
        synchronized (taskList)
        {
            taskList.add(run);
            taskList.notify();
        }
    }

    public void closeTheadPool()
    {
        printLog("开始关闭线程池");
        isRun = false;
        synchronized (taskList)
        {
            taskList.clear();

            for (int i = 0; i < MAX_COUNT; i++)
            {
                printLog("线程池关闭" + worker[i].getName());
                worker[i].stopWorkThread();
            }

            taskList.notifyAll();
        }
    }

    public String getTaskLength()
    {
        return "已经运行" + length + "个任务";
    }

    public String getThreadPoolInfo()
    {
        StringBuffer sb = new StringBuffer();
        sb.append("线程池中共有" + MAX_COUNT + "个线程\n");
        for (int i = 0; i < MAX_COUNT; i++)
        {
            sb.append(worker[i].getName()).append("当前处于").append(worker[i].getState()).append("状态\n");
        }
        return sb.toString();
    }

    public Task getTask()
    {
        Task run = null;
        if (isRun)
        {
            synchronized (taskList)
            {
                while (taskList.isEmpty())
                {
                    try
                    {
                        printLog(Thread.currentThread().getName() + "暂停");
                        taskList.wait();
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }

                    if (!isRun)
                        return null;
                }
                run = taskList.remove(0);
                length++;
            }
        }
        return run;
    }

    public void printLog(String log)
    {
        if (isShowLog)
        {
            System.out.println(log);
        }
    }
}

　　工作线程类

package my.java.threadpool;

public class WorkThread extends Thread
{
    private boolean isRun;
    private ThreadPool pool;
    private boolean isShowLog;

    public WorkThread(ThreadPool pool, String name)
    {
        isRun = true;
        this.pool = pool;
        setName(name);
    }

    @Override
    public void run()
    {
        printLog(getName() + "开启");
        while (isRun)
        {
            Task run = pool.getTask();

            if (null == run)
            {
                continue;
            }
            printLog(getName() + "开始工作");
            try
            {
                run.run();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
            printLog(getName() + "完成工作");
        }

        printLog(getName() + "关闭");
    }

    public void stopWorkThread()
    {
        isRun = false;
    }
    
    public void printLog(String log)
    {
        if (isShowLog)
        {
            System.out.println(log);
        }
    }
}

　　工作接口

package my.java.threadpool;

public interface Task
{
    /**
     * 耗时操作，也就是工作线程具体要做的内容
     */
    public void run();
}

　　测试类

package my.java.threadpool;

import java.util.Random;

public class Test
{
    public static void main(String[] args) throws InterruptedException
    {

        ThreadPool pool = ThreadPool.getInstance();

        System.out.println("开始添加任务");

        for (int i = 0; i < 50; i++)
        {
            Task run = new Task()
            {
                @Override
                public void run()
                {
                    try
                    {
                        Thread.sleep(new Random().nextInt(5) * 1000);
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            };
            pool.addToThreadPool(run);
        }

        System.out.println(pool.getThreadPoolInfo());
        // Thread.sleep(100 * 1000);
        pool.closeTheadPool();
    }
}