线程池的实现原理

package com.test.ThreadPool;

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * 线程池的实现原理
 * @author Flynn
 *
 */
public class ThreadPool {
    private static ThreadPool pool = null;
    
    private final int initNum ;    //初始化线程数量
    private volatile AtomicInteger quenLen = new AtomicInteger(0);    //任务队列长度，volatile修饰的原子操作不必加入同步模块
    private List<Runnable> taskQuen = new LinkedList<Runnable>() ;    //待处理任务队列，涉及其的操作要做线程安全处理（使用linkedlist是因为任务队列插入删除操作比较频繁）
    private workThread[] threads;
    private ThreadPool(int num){
        this.initNum = num ;
        threads = new workThread[initNum] ;
        for(int i=0;i<initNum;i++){
            threads[i] = new workThread() ;
            threads[i].start() ;
        }
    }
    /**
     * 获取单例
     * @param num
     * @return
     */
    public static ThreadPool getPool(int num){
        if(pool == null){
            synchronized (ThreadPool.class) {
                if(pool == null)
                    pool = new ThreadPool(num) ;
            }
        }
        return pool ;
    }
    /**
     * 添加执行任务
     * @param runs
     */
    public void execute(Runnable...runs){
        for(Runnable r : runs){
            //操作共享资源任务队列 需要同步
            synchronized (taskQuen) {
                taskQuen.add(r) ;
                taskQuen.notifyAll() ;
            }
            quenLen.incrementAndGet() ;
        }
    }
    public int getTaskNum(){
        return quenLen.intValue() ;
    }
    public void detory(){
        //如果任存在任务，释放锁对象并等待20ms再次进入可执行状态
        while(!taskQuen.isEmpty()){
            try {
                Thread.sleep(20) ;
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        for(int i=0;i<initNum;i++){
            threads[i].stopWork() ;
            threads[i] = null ;    //设置为null便于垃圾回收
        }
        pool = null ;
        taskQuen.clear() ;
    }
    /**
     * 内部线程类
     * @author Flynn
     *
     */
    private class workThread extends Thread{
        private boolean isRunning = true ;    //通过此标志放行线程，也就是说让线程执行完并销毁
        @Override
        public void run() {
            // TODO Auto-generated method stub
            Runnable run = null ;
            while(isRunning){
                synchronized (taskQuen) {
                    //如果没有任务，释放锁对象并等待20ms再次进入可执行状态
                    while(isRunning && taskQuen.isEmpty()){
                        try {
                            taskQuen.wait(20) ;
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    if(!taskQuen.isEmpty()){
                        //将任务拿出执行，但不是执行成功如否
                        run = taskQuen.remove(0);
                        quenLen.getAndDecrement();
                    }
                }
                //任务执行，因为没有涉及到共享资源，不必放入同步模块
                if(run!=null){
                    run.run() ;
                }
                run = null ;
            }
        }
        public void stopWork(){
            this.isRunning = false ;
        }
    }
}

package com.test.ThreadPool;

import java.util.concurrent.atomic.AtomicInteger;

public class TestMain {

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        ThreadPool pool = ThreadPool.getPool(4) ;
        new TestMain.myRun() ;
        pool.execute(new myRun(),new myRun(),new myRun(),new myRun()) ;
        pool.execute(new myRun(),new myRun(),new myRun(),new myRun()) ;
        pool.execute(new myRun(),new myRun(),new myRun(),new myRun()) ;
        pool.execute(new myRun(),new myRun(),new myRun(),new myRun()) ;
        pool.detory() ;
    }
    static class myRun implements Runnable{
        private static volatile AtomicInteger len = new AtomicInteger(0);    //任务队列长度，原子操作
        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.err.println("任务--"+len.incrementAndGet()+"--执行了");
        }
    }
}

实验结果：

任务--4--执行了
任务--3--执行了
任务--1--执行了
任务--2--执行了
任务--7--执行了
任务--6--执行了
任务--5--执行了
任务--10--执行了
任务--9--执行了
任务--8--执行了
任务--13--执行了
任务--12--执行了
任务--11--执行了
任务--16--执行了
任务--15--执行了
任务--14--执行了

可以看到16个任务全部执行了，没有重复，但是打印的顺序不是递增的，那是因为workThread的run()中任务的执行没有放入同步模块，这也就是只管将任务执行但不控制它具体执行的时间