ava并发学习之二：线程池

第二步，是实现一个线程池 

因为之前看书的时候留了个心眼，看线程池相关的内容的时候特意没去研究JDK的实现 
因为学跟做不是一码事，写一个线程池，算是给自己看完并发实践这书的一个练习吧 

废话不多说，练习开始 

首先，整理一下要实现的功能，或者说要注意的元素 
1.实现Executor接口 
2.实现一个等待队列（可否配置，优先级等） 
3.是否需要预启动线程（可否配置） 
4.执行开始前，结束后，需要留接口 
5.Runable在任务中的存放形式 
6.线程的启动，唤醒 
7.线程池的关闭（优雅地结束），需要线程提供中断，线程池提供给使用者的提示，线程池返回取消线程等 
8.线程队列（空闲队列？） 
9.取空闲线程算法(任务入队时？线程执行一个任务结束时？) 
10.将所有需要同步的地方尽量使用非阻塞算法（通过侦察，更新一个原子变量实现） 
11.减少线程切换开销（轮询是否有任务，n微秒后再进入等待） 

暂时就考虑到这些，剩下的以后再补 

总的来说，计划写n个版本（毕竟是第二次动手，写一个庞大的需要细致考虑的东西功力还差远呢，只能从最简单的，最方便的实现开始，然后慢慢加强） 

测试先行： 

Java代码  

1. public static void main(String[] args) throws InterruptedException  
2. {  
3.     testEasyRunnableThreadPool(new ThreadPoolTest1(10), 10000, 10);  
4.     testEasyRunnableThreadPool(Executors.newFixedThreadPool(10), 10000, 10);  
5. }  
6.   
7. /** 
8.  * 一个产生随机数的方法，防止jvm优化 
9.  * @param seed 
10.  * @return 
11.  */  
12. static int getRandomNum(int seed)  
13. {  
14.     seed ^= (seed << 6);  
15.     seed ^= (seed >>> 21);  
16.     seed ^= (seed << 7);  
17.     return seed;  
18. }  
19.   
20. /** 
21.  * 执行一个简单的计算，只占用cpu，没有io和其他阻塞的方法 
22.  * @param pool 
23.  * @param tryTime 
24.  * @param threadNum 
25.  * @throws InterruptedException 
26.  */  
27. static void testEasyRunnableThreadPool(Executor pool,int tryTime,int threadNum) throws InterruptedException  
28. {  
29.     //construct runnable  
30.     Runnable command = new Runnable() {           
31.         public void run() {  
32.             final int addTime = 1000000;  
33.             long sum = 0;  
34.             int temp = this.hashCode() ^ (int)System.currentTimeMillis();  
35.             for(int i = 0;i<addTime;i++)  
36.             {  
37.                 sum += (temp = getRandomNum(temp));  
38.             }                 
39.         }  
40.     };        
41.     testThreadPool(tryTime, pool, command);  
42. }  
43.   
44. /** 
45.  *  
46.  * @param tryNum  
47.  * @param pool 
48.  * @param commandList 
49.  * @throws InterruptedException 
50.  */  
51. static void testThreadPool(int tryNum,Executor pool,final Runnable command) throws InterruptedException  
52. {  
53.     final CountDownLatch latch = new CountDownLatch(tryNum);  
54.     Runnable wrapper = new Runnable() {           
55.         public void run() {  
56.             command.run();  
57.             //想测试并发，在并发中加入适当的同步操作是无法避免的，只能减少  
58.             //，在这，只是做了一个简单的countdown，影响不大  
59.             latch.countDown();  
60.         }  
61.     };  
62.     long startTime = System.nanoTime();  
63.     for(int i = 0;i<tryNum;i++)  
64.     {  
65.         pool.execute(wrapper);  
66.     }         
67.     latch.await();  
68.     long endTime = System.nanoTime();  
69.     System.out.println(endTime-startTime);  
70. }  

线程池代码： 
第一版本的目标很简单，只要能跑，没死锁，就是完胜 
可惜结果很让人绝望~ 
写完了，调了近3个小时，仍然没发现问题，最后加了一堆输出，又加了多个锁，终于勉勉强强跑起来了…… 
并发的调试真难，debug完全没用，看输出又看不出什么来，只能是一遍一遍地检查代码，写下一个版本前先找点资料，研究下调试方法吧 
后来发现错误是一个简单的i++…… 

Java代码  

1. public class ThreadPoolTest1 implements Executor {  
2.     //等待队列  
3.     Queue<Runnable> waitingQueue = null;  
4.       
5.     ConcurrentLinkedQueue<ThreadNode> freeThread;  
6.     //相当于一个freeThread的状态，根据状态决定行为，原则上将freeThread.size()+busyThreadsNum=MAXTHREADNUM  
7.     private AtomicInteger busyThreadsNum = new AtomicInteger(0);  
8.     //最大线程数  
9.     final int MAXTHREADNUM;  
10.       
11.     public ThreadPoolTest1 (int threadNum)  
12.     {  
13.         this.MAXTHREADNUM = threadNum;  
14.         init(MAXTHREADNUM,new ConcurrentLinkedQueue<Runnable>());  
15.     }     
16.   
17.     private void init(int threadNum,ConcurrentLinkedQueue<Runnable> queue)  
18.     {  
19.         freeThread = new ConcurrentLinkedQueue<ThreadNode>();  
20.         waitingQueue = queue;  
21.         //初始化空线程，一开始不是这样实现的，后来发现一堆问题，暂时只能先加锁，无论怎么样，跑起来再说把  
22.         synchronized(this)  
23.         {  
24.             for(int i = 0;i<threadNum;i++)  
25.             {  
26.                 ThreadNode node = new ThreadNode();  
27.                 busyThreadsNum.incrementAndGet();                 
28.                 node.start();  
29.             }  
30.         }  
31.     }  
32.       
33.     private synchronized void threadExecute(Runnable command)  
34.     {  
35.         //用了个挺弱智的非阻塞算法  
36.         for(;;)  
37.         {  
38.             //得到开始的值  
39.             int expect = busyThreadsNum.get();  
40.             if(expect == MAXTHREADNUM)  
41.             {  
42.                 waitingQueue.add(command);  
43.                 return;  
44.             }  
45.             else  
46.             {  
47.                 //比较并设置，如果失败，重来  
48.                 if(busyThreadsNum.compareAndSet(expect, ++expect))//之前写的是expect++，检查了n久，硬是看不出啥问题，只能怪自己天资愚鲁吧  
49.                 {  
50.                     ThreadNode t = freeThread.remove();  
51.                     t.setCommand(command);  
52.                     synchronized(t)  
53.                     {t.notify();}  
54.                     return;  
55.                 }  
56.                 else  
57.                     continue;