一、前言

 

在软件开发过程中，总会遇到一些瓶颈。开发效率瓶颈，人员技术瓶颈，运行效率瓶颈，服务器瓶颈，磁盘IO瓶颈，CPU、内存瓶颈。这些都限制了我们的软件无法尽善尽美。我们的目的就是为了克服和改善这些难题，使软件比想象中更完美。

 

二、具体问题

 

在数据库或者是流程工作时，很多操作都是由于最初软件设计的原因，或者是当初一些产品设计的原因，或者因为时间紧迫，或者逼不得已必须如此做，然后被设计成同步操作，导致工作效率产生瓶颈，没有充分发挥CPU和内存的功能，但是软件工作起来慢的要死。这时候就需要重构代码了。

 

三、解决方案

 

在CPU和内存还有磁盘IO并没有充分利用的时候，就可以在重构的时候，使用线程操作，将过去需要占用一定时间的同步操作，进行并发处理。这样，创建多个线程来解决同一个问题。这样就可以使操作成为异步，不需要进行等待就可以同时操作很多事情。

那么线程需要创建多少呢？

每监听到一个请求就创建一个线程，然后操作之后就销毁。这种办法可行么？

 

如果突然在客户端提交了1000000 * N 个请求，这些请求都进入服务器，然后在这里，为每一个请求都创建一个线程来执行。这样程序就会失去控制。最终挤爆服务器CPU和内存，使程序崩溃。

 

怎么样合理、可控的处理操作，变成了重点。

 

四、线程池的概念

 

线程池，顾名思义，在池化开发的现在，如数据库连接池这种开发模式已经广泛流行。

在池中创建连接实例，在访问数据库时，从连接池中取得连接，操作之后归还。这样就可以有效的限制资源数量，但是又能提高操作速度。

1.package test.dao;   
2.  
3.import java.util.LinkedList;   
4.  
5.import org.apache.log4j.Logger;   
6.  
7.  
8./**  
9. *   
10. * @author Andy.xiaomeng  
11. *  
12. */  
13.public class ThreadPool {   
14.  
15.    private static final Logger Log = Logger.getLogger(ThreadPool.class);   
16.       
17.    private ThreadWorker[] worker;   
18.    private LinkedList<Runnable> queue;   
19.    private int poolSize;   
20.       
21.    public int getPoolSize(){   
22.        return poolSize;   
23.    }   
24.       
25.    //initialize thread pool with pool size   
26.    public ThreadPool(int size){   
27.           
28.        poolSize = size;   
29.        worker = new ThreadWorker[size];   
30.        queue = new LinkedList<Runnable>();   
31.           
32.        for (int i = 0; i < size; i++) {   
33.            worker[i] = new ThreadWorker();    
34.            worker[i].start();   
35.        }   
36.           
37.    }   
38.       
39.       
40.       
41.    //add work queue   
42.    public void addQueue(Runnable runnable){   
43.        synchronized(queue) {   
44.            queue.add(runnable);   
45.            queue.notify();   
46.        }   
47.    }   
48.       
49.    //worker do work   
50.    private class ThreadWorker extends Thread{   
51.           
52.        public void run(){   
53.               
54.            //runnable   
55.            Runnable runable;   
56.               
57.            while (true) {   
58.                   
59.                synchronized(queue) {   
60.                    while (queue.isEmpty()) {   
61.                        try  
62.                        {   
63.                            //is work queue is empty, wait   
64.                            queue.wait();   
65.                        }   
66.                        catch (Exception e)   
67.                        {   
68.                            Log.error("pool queue wait", e);   
69.                        }   
70.                    }   
71.                       
72.                    //get work in queue, and remove it    
73.                    runable = queue.removeFirst();   
74.                }   
75.  
76.                try {   
77.                    //do work   
78.                    runable.run();   
79.                }   
80.                catch (RuntimeException e) {   
81.                    Log.error("unknow runtime exception", e);   
82.                }   
83.                   
84.            }   
85.        }   
86.           
87.    }   
88.       
89.    public static void main(String[] args) {   
90.           
91.        //test   
92.        ThreadPool pool = new ThreadPool(111);   
93.           
94.           
95.        //   
96.        class SSS implements Runnable{   
97.            private String abc;   
98.            public void setAbc(String aaaaa){   
99.                this.abc = aaaaa;   
100.            }   
101.               
102.            public void run() {   
103.                System.out.println("do runnable " + abc);   
104.            }   
105.        }   
106.           
107.        for (int i = 0; i < 200; i++) {   
108.            SSS a = new SSS();   
109.            a.setAbc(String.valueOf(i + 1));   
110.            pool.addQueue(a);   
111.        }   
112.           
113.    }   
114.}