`
xmong
  • 浏览: 263325 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

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}

。。。。




分享到:
评论

相关推荐

    java多线程设计模式详解

    Java多线程设计模式是Java编程中不可或缺的一部分,它涉及到如何在并发环境下高效、安全地组织代码执行。本文将深入探讨几种常见的Java多线程设计模式,并提供源码实例进行详细解析。 一、生产者消费者模式 生产者...

    java多线程设计模式

    Java多线程设计模式是Java开发中不可或缺的一部分,它涉及到如何高效、安全地在多个执行线程之间共享资源和协调任务。多线程是并发处理的基石,它使得程序能够同时执行多个不同的任务,从而提高了系统性能。在这个...

    Java多线程设计模式源代码

    本文将深入探讨Java多线程设计模式及其源代码,旨在帮助开发者理解和应用这些模式,提升代码的并发性能和可维护性。 1. **生产者消费者模式**:该模式基于`BlockingQueue`,例如`ArrayBlockingQueue`,用于在生产...

    java多线程设计模式详解.rar

    Java多线程设计模式是Java开发中不可或缺的一部分,它涉及到并发编程的核心概念和技术。在Java中,多线程可以提高程序的执行效率,通过合理利用CPU资源,使得多个任务能够同时进行。本压缩包文件“java多线程设计...

    java多线程设计模式详解(PDF及源码)

    本资源“java多线程设计模式详解”涵盖了这一主题的深入探讨,包括PDF文档和源码示例。 多线程设计模式是程序员在开发高效、稳定且可维护的多线程应用程序时遵循的一系列最佳实践。以下是一些常见的Java多线程设计...

    多线程控制,线程池模式,HTTP线程

    在IT领域,多线程控制、线程池模式和HTTP线程是三个关键概念,尤其在高并发和高性能系统设计中扮演着重要角色。本文将深入探讨这些知识点,并结合实际应用进行阐述。 首先,让我们从多线程控制开始。多线程是指在一...

    java基础知识多线程线程池讲解和练习

    Java多线程与线程池是Java编程中的核心概念,特别是在构建高性能、高并发的应用时不可或缺。本资源旨在深入解析这两个关键知识点,并提供实践练习,帮助开发者熟练掌握它们。 首先,我们要理解什么是Java多线程。在...

    java多线程详解(比较详细的阐述了多线程机制)

    Java多线程还涉及到线程中断和异常处理,Thread类提供了interrupt()方法发起中断请求,线程可以通过检查isInterrupted()或isInterrupted()状态响应中断。在多线程环境中,异常处理也需特别注意,合理的try-catch-...

    图灵图书:图解JAVA多线程设计模式

    ### 图灵图书:图解JAVA多线程设计模式 #### 关键知识点概览 - **Java多线程基础** - 线程的概念与创建方式 - 线程的状态及其转换 - 线程生命周期 - **Java并发编程** - 同步机制(synchronized关键字) - ...

    Java多线程编程实战指南 设计模式篇

    《Java多线程编程实战指南 设计模式篇》是一本深度探讨Java并发编程与设计模式融合的书籍。在Java编程中,多线程是提升系统性能、实现并行计算的关键技术,而设计模式则是解决常见问题的最佳实践。本书旨在帮助...

    java多线程设计模式&amp;javaSocket&amp;java实用教程2.zip

    一、Java多线程设计模式 1. **生产者消费者模式**:在并发编程中,生产者负责生成数据,消费者负责消费数据。通过使用阻塞队列,可以确保生产者和消费者之间的同步,避免数据丢失或过度填充。 2. **单例模式**:...

    java多线程高级设计模式详解

    Java多线程高级设计模式详解 在Java编程中,多线程是不可或缺的一...以上就是Java多线程高级设计模式的一些主要内容,理解并熟练运用这些模式,能让你在处理并发问题时更加得心应手,编写出高效且健壮的多线程程序。

    Java多线程编程

    Java多线程编程是Java开发中的重要组成部分,它允许程序同时执行多个任务,极大地提高了程序的效率和响应性。在Java中,多线程主要通过`Thread`类和并发工具来实现,接下来我们将深入探讨这些关键知识点。 1. **...

    epoll 多线程 线程池

    最后,尝试自己编写一个简单的应用,例如一个使用epoll的TCP服务器,配合多线程和线程池处理客户端请求,以此巩固所学知识。 总之,epoll、多线程和线程池是构建高性能、高并发系统的关键技术,熟练掌握它们对于...

Global site tag (gtag.js) - Google Analytics