java多线程设计模式之线程池处理请求

Java实现线程池处理请求：

客户端线程发出请求，请求存入请求队列中，服务器端线程池不断从请求列表中拿出请求，执行请求。服务器端用线程池实现多线程处理请求，线程实例在使用的时候已经被创建，直接使用实例，提供程序的执行效率。

设计如下：
Request：请求类，存储请求信息，携带请求的执行方法。
RequestQueue：存储请求队列类，负责保存请求的存储和取出。
ClientThread：客户端线程类，负责发送请求。
ServerThread：服务端线程类，负责获取请求并执行请求。
ServerThreadPool：服务端线程池类，负责初始化线程数，管理线程。
Main：main类。

实现如下：

Request：请求类

package com.thread.pool;

import java.util.Random;

/**
 * 请求类
 * @author Administrator
 * 
 */
public class Request {
	
	/**
	 * 请求名称
	 */
	private final String name;
	
	private final Random random = new Random();
	
	public Request(String name){
		this.name = name;
	}
	
	public String getName(){
		return name;
	}
	
	/**
	 * 请求执行方法
	 */
	public void execute(){
		System.out.println(Thread.currentThread().getName()+" execute "+getName());
		try {
			Thread.sleep(random.nextInt(3000));//摸拟执行时间
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	public String toString(){
		return "{"+name+"}";
	}
	
	
}

RequestQueue：请求队列类，负责存储请求。

package com.thread.pool;

import java.util.LinkedList;

/**
 * 请求队列类
 * @author Administrator
 *
 */
public class RequestQueue {
	
        //存储请求列表
	private LinkedList<Request> requests = new LinkedList<Request>();
	//请求列表大小
	private int size;
	
	public RequestQueue(int size){
		this.size = size;
	};
	
	/**
	 * 添加请求
	 * @param request
	 */
	public synchronized void putRequest(Request request){
		
		while(requests.size() > size){//判断请求队列中是否达到队列容量
			try {
				System.out.println(Thread.currentThread().getName()+" {putRequest wait}");
				wait();//添加线程等待
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		requests.addLast(request);//添加请求
		System.out.println(Thread.currentThread().getName()+" putRequest "+request);
		notifyAll();//唤醒其他等待线程
	};
	
	
	/**
	 * 获取请求
	 * @return
	 */
	public synchronized Request getRequest(){
		
		while(requests.size() <= 0){//判断是否队列中是否存在请求
			try {
				System.out.println(Thread.currentThread().getName()+" {getRequest wait}");
				wait();//消费线程等待
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		Request request = requests.removeFirst();//取出请求
		System.out.println(Thread.currentThread().getName()+" getRequest "+request);
		notifyAll();//唤醒其他线程
		return request;
	};
	
	
}

ClientThread：客户端线程类，负责发生请求

package com.thread.pool;

import java.util.Random;

/**
 * 客户端线程类
 * @author Administrator
 *
 */
public class ClientThread extends Thread{
	
	//请求队列
	private RequestQueue requestQueue;
	private Random random = new Random();
	
	public ClientThread(String name, RequestQueue queue){
		super(name);
		this.requestQueue = queue;
	}
	
	/**
	 * 循环产生请求
	 */
	public void run(){
		int count = 0;
		while(true){
			Request request = new Request("request."+count+"."+this.getName());
			requestQueue.putRequest(request);//添加请求
			count++;
			try {
				Thread.sleep(random.nextInt(1000));//随机休息
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}

ServerThread：服务端线程类，负责获取请求执行请求。

package com.thread.pool;

/**
 * 服务端线程类
 * @author Administrator
 *
 */
public class ServerThread  extends  Thread{
	
	//请求队列
	private RequestQueue requestQueue;
	
	public ServerThread(String name, RequestQueue requestQueue){
		super(name);
		this.requestQueue = requestQueue;
	}

	/**
	 * 获取请求处理请求
	 */
	public void run (){
		while (true) {
			Request request = requestQueue.getRequest();//获取队列中的请求
			request.execute();//执行请求方法
		}
	}
	
	
}

ServerThreadPool：服务端线程池，初始化线程，管理服务线程。

package com.thread.pool;

/**
 * 服务端线程池
 * @author Administrator
 *
 */
public class ServerThreadPool {

	//存储线程数组
	private ServerThread[] serverThreads;
	//请求队列
	private RequestQueue requestQueue;
	
	/**
	 * 线程池构造方法
	 * @param queue 队列
	 * @param size 线程池大小
	 */
	public ServerThreadPool(RequestQueue queue, int size) {
		this.requestQueue = queue;
		//初始化线程池
		this.serverThreads = new ServerThread[size];
		for (int i = 0; i < size; i++) {
			serverThreads[i] = new ServerThread("ServerThread."+i, requestQueue);
		}
	}
	
	/**
	 * 循环启动线程池中的线程
	 */
	public void start(){
		for (int i = 0; i < serverThreads.length; i++) {
			serverThreads[i].start();
		}
	}
	
	
	
}

Main：mian类。

package com.thread.pool;

/**
 * main类
 * @author Administrator
 *
 */
public class Main {
	
	public static void main(String[] args) {
		//创建队列
		RequestQueue queue = new RequestQueue(3);
		//创建线程池
		ServerThreadPool pool = new ServerThreadPool(queue, 5);
		//启动客户端线程发送请求
		new ClientThread("ClientThread.A", queue).start();
		new ClientThread("ClientThread.B", queue).start();
		//启动线程池处理请求
		pool.start();
		
	}

}

执行结果：

ClientThread.A putRequest {request.0.ClientThread.A}
ClientThread.B putRequest {request.0.ClientThread.B}
ServerThread.1 getRequest {request.0.ClientThread.A}
ServerThread.1 execute request.0.ClientThread.A
ServerThread.0 getRequest {request.0.ClientThread.B}
ServerThread.3 {getRequest wait}
ServerThread.0 execute request.0.ClientThread.B
ServerThread.2 {getRequest wait}
ServerThread.4 {getRequest wait}
ServerThread.0 {getRequest wait}
ClientThread.A putRequest {request.1.ClientThread.A}
ServerThread.0 getRequest {request.1.ClientThread.A}
ServerThread.0 execute request.1.ClientThread.A
ServerThread.4 {getRequest wait}
ServerThread.2 {getRequest wait}
ServerThread.3 {getRequest wait}
ClientThread.B putRequest {request.1.ClientThread.B}
ServerThread.3 getRequest {request.1.ClientThread.B}
ServerThread.3 execute request.1.ClientThread.B
ServerThread.2 {getRequest wait}
ServerThread.4 {getRequest wait}
ClientThread.A putRequest {request.2.ClientThread.A}
ServerThread.4 getRequest {request.2.ClientThread.A}
ServerThread.4 execute request.2.ClientThread.A
ServerThread.2 {getRequest wait}
ClientThread.B putRequest {request.2.ClientThread.B}
ServerThread.2 getRequest {request.2.ClientThread.B}
ServerThread.2 execute request.2.ClientThread.B
ClientThread.B putRequest {request.3.ClientThread.B}
ClientThread.A putRequest {request.3.ClientThread.A}
ClientThread.B putRequest {request.4.ClientThread.B}
ClientThread.A putRequest {request.4.ClientThread.A}
ServerThread.1 getRequest {request.3.ClientThread.B}
ServerThread.1 execute request.3.ClientThread.B
ServerThread.3 getRequest {request.3.ClientThread.A}
ServerThread.3 execute request.3.ClientThread.A
ServerThread.4 getRequest {request.4.ClientThread.B}
ServerThread.4 execute request.4.ClientThread.B
ClientThread.A putRequest {request.5.ClientThread.A}
ClientThread.B putRequest {request.5.ClientThread.B}
ClientThread.B putRequest {request.6.ClientThread.B}
ClientThread.A {putRequest wait}
ServerThread.2 getRequest {request.4.ClientThread.A}
ServerThread.2 execute request.4.ClientThread.A
ClientThread.A putRequest {request.6.ClientThread.A}

。。。。