简单的线程池实现

朴灿烈づ我的快乐病毒、 2022-05-24 12:09 162阅读 0赞

为了节省系统在并发时不断创建和销毁线程所带来的额外开销，就需要引入线程池。线程池的基本思想是，线程使用完后并不销毁，而是一直处于等待状态，如果下一个任务进入，可以再使用这个线程执行，这样就减少了线程的创建和销毁。  
首先是线程池的实现：

package com.mr.smart.future.simplethreadpool;
    
    import java.util.List;
    import java.util.Vector;
    
    public class ThreadPool { 
        private static ThreadPool instance = null;
        //空闲的线程队列
        private List<PThread> idleThreads;
        //已有的线程总数
        private int threadCounter;
        private boolean isShutDown = false;
    
        private ThreadPool() {
            this.idleThreads = new Vector<>(5);
            threadCounter = 0;
        }
    
        public int getThreadCounter() {
            return threadCounter;
        }
    
    
        //取得线程池的实例
        public synchronized static ThreadPool getInstance() {
            if (instance == null)
                instance = new ThreadPool();
            return instance;
        }
    
        //将线程放入池中
        protected synchronized void repool(PThread repoolingThread) {
            if (!isShutDown) {
                idleThreads.add(repoolingThread);
            } else {
                repoolingThread.shutDown();
            }
        }
    
        //停止池中所有线程
        public synchronized void shutDown() {
            isShutDown = true;
            for (int threadIndex = 0; threadIndex < idleThreads.size(); threadIndex++) {
                PThread idleThread = idleThreads.get(threadIndex);
                idleThread.shutDown();
            }
        }
    
        //执行任务
        public synchronized void start(Runnable target) {
            PThread thread = null;
            if (idleThreads.size() > 0) {
                int lastIndex = idleThreads.size() - 1;
                thread = (PThread) idleThreads.get(lastIndex);
                idleThreads.remove(lastIndex);
                //立即执行这个任务
                thread.setTarget(target);
            } else {
                threadCounter++;
                thread = new PThread(target, "PThread #" + threadCounter, this);
                // 启动这个线程
                thread.start();
            }
        }
    
    
    }

配合线程：

package com.mr.smart.future.simplethreadpool;
    
    public class PThread extends Thread { 
        //线程池
        private ThreadPool pool;
        //任务
        private Runnable target;
        private boolean isShutDown = false;
        private boolean isIdle = false;
    
        //构造函数
        public PThread(Runnable target, String name, ThreadPool pool) {
            super(name);
            this.pool = pool;
            this.target = target;
        }
    
        public Runnable getTarget() {
            return target;
        }
    
        public boolean isIdle() {
            return isIdle;
        }
    
        @Override
        public void run() {
            //只要没有关闭，则一直不结束该线程
            while (!isShutDown) {
                isIdle = false;
                if (target != null) {
                    //运行任务
                    target.run();
                }
                //任务结束了，到闲置状态
                isIdle = true;
                try {
                    //该任务结束后，不关闭线程，而是放入线程池空闲队列
                    pool.repool(this);
                    synchronized (this) {
                        //线程空闲，等待新的任务到来
                        wait();
                    }
                } catch (InterruptedException e) {
    
                }
                isIdle = false;
            }
        }
    
        public synchronized void setTarget(Runnable newTarget) {
            target = newTarget;
            notifyAll();
        }
    
        //关闭线程
        public synchronized void shutDown() {
            isShutDown = true;
            notifyAll();
        }
    }