本文共 5871 字，大约阅读时间需要 19 分钟。

最近项目中用到了线程池，俗话说的好，了解他才能打败他，于是自己写了一个简单的线程池拿来实验

1、线程接口，定义线程池中的主要的几个方法

import java.util.List;/** * @Author: wuyaohua * @Description: 线程接口 * @Date: Created in 11:33 2018-08-21 */public interface IThreadPool {    /**      * @Author : wuyaohua      * @Date : 2018-08-21  11:34      * @Description :  加入任务      * @Param : [task]      * @Return : void    */    void execute(Runnable task);    /**     * @Author : wuyaohua     * @Date : 2018-08-21  11:34     * @Description :  加入任务     * @Param : [task]     * @Return : void     */    void execute(Runnable[] tasks);    /**     * @Author : wuyaohua     * @Date : 2018-08-21  11:34     * @Description :  加入任务     * @Param : [task]     * @Return : void     */    void execute(List
   
     tasks);    /**     * @Author : wuyaohua     * @Date : 2018-08-21  11:34     * @Description :  销毁线程     * @Param : [task]     * @Return : void     */    void destroy();}
   

2、线程池实现类

import java.util.LinkedList;import java.util.List;import java.util.concurrent.atomic.AtomicLong;/** * @Author: wuyaohua * @Description: 线程池实现类 * @Date: Created in 11:35 2018-08-21 */@SuppressWarnings("ALL")public class ThreadPoolImpl implements IThreadPool {    /**     * 默认开启线程个数     */    static int WORKER_NUMBER = 5;    /**     * 完成任务线程数 可见性     */    static volatile int sumCount = 0;    /**     * 任务队列 list非线程安全，可以优化为BlockingQueue     */    static List
   
     taskQueue = new LinkedList
    
     ();    /**     * 线程工作组     */    WorkerThread[] workThreads;    /**    * 原子性    */    static AtomicLong threadNum = new AtomicLong();    static ThreadPoolImpl threadPool;    //构造方法    public ThreadPoolImpl() {        this(WORKER_NUMBER);    }    public ThreadPoolImpl(int workerNum) {        ThreadPoolImpl.WORKER_NUMBER = workerNum;        //开辟工作线程空间        workThreads = new WorkerThread[WORKER_NUMBER];        //开始创建工作线程        for (int i = 0; i < WORKER_NUMBER; i++) {            workThreads[i] = new WorkerThread();            Thread thread = new Thread(workThreads[i], "ThreadPool-worker" + threadNum.incrementAndGet());            System.out.println("初始化线程数" + (i + 1) + "---------当前线程名称:" + thread.getName());            thread.start();        }    }    @Override    public String toString() {        return "工作线程数量为" + WORKER_NUMBER                + "已完成的任务数" + sumCount +                "等待任务数量" + taskQueue.size();    }    //获取线程池    public static IThreadPool getThreadPool() {        return getThreadPool(WORKER_NUMBER);    }    public static IThreadPool getThreadPool(int workerNum) {        //容错性，如果小于等于0就默认线程数        if (workerNum <= 0) {            workerNum = WORKER_NUMBER;        }        if (threadPool == null) {            threadPool = new ThreadPoolImpl(workerNum);        }        return threadPool;    }    @Override    public void execute(Runnable task) {        synchronized (taskQueue) {            taskQueue.add(task);            taskQueue.notifyAll();        }    }    @Override    public void execute(Runnable[] tasks) {        synchronized (taskQueue) {            for (Runnable task : tasks) {                taskQueue.add(task);            }            taskQueue.notifyAll();        }    }    @Override    public void execute(List
     
       tasks) {        synchronized (taskQueue) {            for (Runnable task : tasks) {                taskQueue.add(task);            }            taskQueue.notifyAll();        }    }    @Override    public void destroy() {        //循环是否还存在任务，如果存在等待20毫秒处理时间        while (!taskQueue.isEmpty()) {            try {                Thread.sleep(20);            } catch (InterruptedException e) {                e.printStackTrace();            }        }        //如果任务队列已处理完成，销毁线程，清空任务        for (int i = 0; i < WORKER_NUMBER; i++) {            workThreads[i].setWorkerFlag();            workThreads[i] = null;        }        threadPool = null;        taskQueue.clear();    }    /**     * 创建工作线程池     */    class WorkerThread extends Thread {        /**        * 用来标识当前线程属于活动可用状态        */        private boolean isRunning = true;        @Override        public void run() {            Runnable runnable = null;            //死循环            while (isRunning) {                //非线程安全，所以采用同步锁                synchronized (taskQueue) {                    while (isRunning && taskQueue.isEmpty()) {                        try {                            //如果任务队列为空，等待20毫秒 监听任务到达                            taskQueue.wait(20);                        } catch (Exception e) {                            e.printStackTrace();                        }                    }                    //任务队列不为空                    if (!taskQueue.isEmpty()) {                        //获取第一个任务                        runnable = taskQueue.remove(0);                    }                }                if (runnable != null) {                    runnable.run();                }                sumCount++;                runnable = null;            }        }        /**        * 销毁线程        */        public void setWorkerFlag() {            isRunning = false;        }    }}
     
    
   

3、线程池测试类

import java.util.ArrayList;import java.util.List;/** * @Author: wuyaohua * @Description: 线程池测试类 * @Date: Created in 11:41 2018-08-21 */public class ThreadPoolTest {    public static void main(String[] args) {        //获取线程池        IThreadPool t = ThreadPoolImpl.getThreadPool(20);        List
   
     taskList = new ArrayList
    
     ();        for (int i = 0; i < 100; i++) {            taskList.add(new Task());        }        //执行任务        t.execute(taskList);        System.out.println(t);        //销毁线程        t.destroy();        System.out.println(t);    }    static class Task implements Runnable {        private static volatile int i = 1;        @Override        public void run() {            System.out.println("当前处理的线程:" + Thread.currentThread().getName() + " 执行任务" + (i++) + " 完成");        }    }}
    
   

转载地址：https://blog.csdn.net/JohneyWu/article/details/81916840 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！