一切为了资源与效率：Java线程池

一、前言

 

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

 

二、具体问题

 

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

 

三、解决方案

 

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

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

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

 

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

 

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

 

四、线程池的概念

 

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

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

 

五、编码示意

 

package test.dao;

import java.util.LinkedList;

import org.apache.log4j.Logger;


/**
 * 
 * @author Andy.xiaomeng
 *
 */
public class ThreadPool {

	private static final Logger Log = Logger.getLogger(ThreadPool.class);
	
	private ThreadWorker[] worker;
	private LinkedList<Runnable> queue;
	private int poolSize;
	
	public int getPoolSize(){
		return poolSize;
	}
	
	//initialize thread pool with pool size
	public ThreadPool(int size){
		
		poolSize = size;
		worker = new ThreadWorker[size];
		queue = new LinkedList<Runnable>();
		
		for (int i = 0; i < size; i++) {
			worker[i] = new ThreadWorker(); 
			worker[i].start();
		}
		
	}
	
	
	
	//add work queue
	public void addQueue(Runnable runnable){
		synchronized(queue) {
			queue.add(runnable);
			queue.notify();
		}
	}
	
	//worker do work
	private class ThreadWorker extends Thread{
		
		public void run(){
			
			//runnable
			Runnable runable;
			
			while (true) {
				
				synchronized(queue) {
                    while (queue.isEmpty()) {
                        try
                        {
                        	//is work queue is empty, wait
                            queue.wait();
                        }
                        catch (Exception e)
                        {
                        	Log.error("pool queue wait", e);
                        }
                    }
                    
                    //get work in queue, and remove it 
                    runable = queue.removeFirst();
                }

                try {
                	//do work
                	runable.run();
                }
                catch (RuntimeException e) {
                	Log.error("unknow runtime exception", e);
                }
				
			}
		}
		
	}
	
	public static void main(String[] args) {
		
		//test
		ThreadPool pool = new ThreadPool(111);
		
		
		//
		class SSS implements Runnable{
			private String abc;
			public void setAbc(String aaaaa){
				this.abc = aaaaa;
			}
			
			public void run() {
				System.out.println("do runnable " + abc);
			}
		}
		
		for (int i = 0; i < 200; i++) {
			SSS a = new SSS();
			a.setAbc(String.valueOf(i + 1));
			pool.addQueue(a);
		}
		
	}
}

 英文不好，中文语法的英文注释，直译吧。。。。。。

 

 附带了main方法的测试案例。

 

 首先创建线程池对象，设置创建线程数量。

 

 将需要做的事情，封装成一个Runnable ，然后添加到队列中。

 

 队列通知线程执行操作。

 

觉得有用帮顶下，帮到你了请回复。。谢谢= =

评论

6 楼 leafyyq 2011-11-17  

[size=large][size=small][color=red]LZ 你好帅哦~~！  [/color][/[color=orange][/color]size][/size]

5 楼 huoyj 2011-10-26  

楼主的这个可以作为一个理解线程池原理的例子确实简洁明了，不过JDK里面已经提供了，为什么不直接去用，功能还更强大。

4 楼 smm11230704 2011-10-25  

tan4836128 写道

有成功应用并实现的案例么，
研究LZ的代码只是看到实现的一种思路，不知上述代码能否实现LZ所说“1000000 * N 个请求”？
强烈建议附上性能分析，希望能有后续跟进

理论上来讲，只要你CPU和内存允许，你线程数你可以随意开的。
不过，能省则省。毕竟其他地方也是要资源的。
利用不能过度也不能过于清闲。
合理才是根本

3 楼 smm11230704 2011-10-25  

tan4836128 写道

有成功应用并实现的案例么，
研究LZ的代码只是看到实现的一种思路，不知上述代码能否实现LZ所说“1000000 * N 个请求”？
强烈建议附上性能分析，希望能有后续跟进

有的，我优化版本的代码就是用了这个线程池实现的。

一般都是使用20个线程来做。
之前很多同步的数据库操作阻塞操作。导致很多消息发送延时（移动互联网项目）

。所以现在重构了一下。

2 楼 dengli 2011-10-25  

Mark!

1 楼 tan4836128 2011-10-25  

有成功应用并实现的案例么，
研究LZ的代码只是看到实现的一种思路，不知上述代码能否实现LZ所说“1000000 * N 个请求”？
强烈建议附上性能分析，希望能有后续跟进