`
cuizhenfu#gmail.com
  • 浏览: 67201 次
  • 性别: Icon_minigender_1
  • 来自: 北京
文章分类
社区版块
存档分类
最新评论

转载java多线程设计模式(二)

阅读更多
http://xuefeng.javaeedev.com

Guarded Suspention

Guarded Suspention模式主要思想是:

当条件不满足时,线程等待,直到条件满足时,等待该条件的线程被唤醒。

我们设计一个客户端线程和一个服务器线程,客户端线程不断发送请求给服务器线程,服务器线程不断处理请求。当请求队列为空时,服务器线程就必须等待,直到客户端发送了请求。

先定义一个请求队列:Queue

java 代码
 
  1. package com.javaeedev.thread;  
  2.   
  3. import java.util.*;  
  4.   
  5. public class Queue {  
  6.     private List queue = new LinkedList();  
  7.     public synchronized Request getRequest() {  
  8.         while(queue.size()==0) {  
  9.             try {  
  10.                 this.wait();  
  11.             }  
  12.             catch(InterruptedException ie) {  
  13.                 return null;  
  14.             }  
  15.         }  
  16.         return (Request)queue.remove(0);  
  17.     }  
  18.   
  19.     public synchronized void putRequest(Request request) {  
  20.         queue.add(request);  
  21.         this.notifyAll();  
  22.     }  
  23.   
  24. }  

 

蓝色部分就是服务器线程的等待条件,而客户端线程在放入了一个request后,就使服务器线程等待条件满足,于是唤醒服务器线程。

客户端线程:ClientThread

java 代码
 
  1. package com.crackj2ee.thread;  
  2.   
  3. public class ClientThread extends Thread {  
  4.     private Queue queue;  
  5.     private String clientName;  
  6.   
  7.     public ClientThread(Queue queue, String clientName) {  
  8.         this.queue = queue;  
  9.         this.clientName = clientName;  
  10.     }  
  11.   
  12.     public String toString() {  
  13.         return "[ClientThread-" + clientName + "]";  
  14.     }  
  15.   
  16.     public void run() {  
  17.         for(int i=0; i<100; i++) {  
  18.             Request request = new Request("" + (long)(Math.random()*10000));  
  19.             System.out.println(this + " send request: " + request);  
  20.             queue.putRequest(request);  
  21.             try {  
  22.                 Thread.sleep((long)(Math.random() * 10000 + 1000));  
  23.             }  
  24.             catch(InterruptedException ie) {  
  25.             }  
  26.         }  
  27.         System.out.println(this + " shutdown.");  
  28.     }  
  29. }  

 

服务器线程:ServerThread

java 代码
 
  1. package com.crackj2ee.thread;  
  2. public class ServerThread extends Thread {  
  3.     private boolean stop = false;  
  4.     private Queue queue;  
  5.   
  6.     public ServerThread(Queue queue) {  
  7.         this.queue = queue;  
  8.     }  
  9.   
  10.     public void shutdown() {  
  11.         stop = true;  
  12.         this.interrupt();  
  13.         try {  
  14.             this.join();  
  15.         }  
  16.         catch(InterruptedException ie) {}  
  17.     }  
  18.   
  19.     public void run() {  
  20.         while(!stop) {  
  21.             Request request = queue.getRequest();  
  22.             System.out.println("[ServerThread] handle request: " + request);  
  23.             try {  
  24.                 Thread.sleep(2000);  
  25.             }  
  26.             catch(InterruptedException ie) {}  
  27.         }  
  28.         System.out.println("[ServerThread] shutdown.");  
  29.     }  
  30. }  

 

服务器线程在红色部分可能会阻塞,也就是说,Queue.getRequest是一个阻塞方法。这和java标准库的许多IO方法类似。

最后,写一个Main来启动他们:

java 代码
 
  1. package com.crackj2ee.thread;  
  2.   
  3. public class Main {  
  4.   
  5.     public static void main(String[] args) {  
  6.         Queue queue = new Queue();  
  7.         ServerThread server = new ServerThread(queue);  
  8.         server.start();  
  9.         ClientThread[] clients = new ClientThread[5];  
  10.         for(int i=0; i             clients[i] = new ClientThread(queue, ""+i);  
  11.             clients[i].start();  
  12.         }  
  13.         try {  
  14.             Thread.sleep(100000);  
  15.         }  
  16.         catch(InterruptedException ie) {}  
  17.         server.shutdown();  
  18.     }  
  19. }  

 

我们启动了5个客户端线程和一个服务器线程,运行结果如下:

[ClientThread-0] send request: Request-4984
[ServerThread] handle request: Request-4984
[ClientThread-1] send request: Request-2020
[ClientThread-2] send request: Request-8980
[ClientThread-3] send request: Request-5044
[ClientThread-4] send request: Request-548
[ClientThread-4] send request: Request-6832
[ServerThread] handle request: Request-2020
[ServerThread] handle request: Request-8980
[ServerThread] handle request: Request-5044
[ServerThread] handle request: Request-548
[ClientThread-4] send request: Request-1681
[ClientThread-0] send request: Request-7859
[ClientThread-3] send request: Request-3926
[ServerThread] handle request: Request-6832
[ClientThread-2] send request: Request-9906
......

可以观察到ServerThread处理来自不同客户端的请求。

思考

Q: 服务器线程的wait条件while(queue.size()==0)能否换成if(queue.size()==0)?

A: 在这个例子中可以,因为服务器线程只有一个。但是,如果服务器线程有多个(例如Web应用程序有多个线程处理并发请求,这非常普遍),就会造成严重问题。

Q: 能否用sleep(1000)代替wait()?

A: 绝对不可以。sleep()不会释放锁,因此sleep期间别的线程根本没有办法调用getRequest()和putRequest(),导致所有相关线程都被阻塞。

Q: (Request)queue.remove(0)可以放到synchronized() {}块外面吗?

A: 不可以。因为while()是测试queue,remove()是使用queue,两者是一个原子操作,不能放在synchronized外面。

总结

多线程设计看似简单,实际上必须非常仔细地考虑各种锁定/同步的条件,稍不小心,就可能出错。并且,当线程较少时,很可能发现不了问题,一旦问题出现又难以调试。

所幸的是,已有一些被验证过的模式可以供我们使用,我们会继续介绍一些常用的多线程设计模式。

源代码地址:http://javaeedev.googlecode.com/svn/trunk/GuardedSuspension/


Zip包下载:http://javaeedev.googlecode.com/files/GuardedSuspension.zip


Worker Pattern

前面谈了多线程应用程序能极大地改善用户相应。例如对于一个Web应用程序,每当一个用户请求服务器连接时,服务器就可以启动一个新线程为用户服务。

然而,创建和销毁线程本身就有一定的开销,如果频繁创建和销毁线程,CPU和内存开销就不可忽略,垃圾收集器还必须负担更多的工作。因此,线程池就是为了避免频繁创建和销毁线程。

每当服务器接受了一个新的请求后,服务器就从线程池中挑选一个等待的线程并执行请求处理。处理完毕后,线程并不结束,而是转为阻塞状态再次被放入线程池中。这样就避免了频繁创建和销毁线程。

Worker Pattern实现了类似线程池的功能。首先定义Task接口:

java 代码
  1. package com.crackj2ee.thread;  
  2. public interface Task {  
  3.     void execute();  
  4. }  

线程将负责执行execute()方法。注意到任务是由子类通过实现execute()方法实现的,线程本身并不知道自己执行的任务。它只负责运行一个耗时的execute()方法。

 

具体任务由子类实现,我们定义了一个CalculateTask和一个TimerTask:

java 代码
 
  1. // CalculateTask.java  
  2. package com.crackj2ee.thread;  
  3. public class CalculateTask implements Task {  
  4.     private static int count = 0;  
  5.     private int num = count;  
  6.     public CalculateTask() {  
  7.         count++;  
  8.     }  
  9.     public void execute() {  
  10.         System.out.println("[CalculateTask " + num + "] start...");  
  11.         try {  
  12.             Thread.sleep(3000);  
  13.         }  
  14.         catch(InterruptedException ie) {}  
  15.         System.out.println("[CalculateTask " + num + "] done.");  
  16.     }  
  17. }  
  18.   
  19. // TimerTask.java  
  20. package com.crackj2ee.thread;  
  21. public class TimerTask implements Task {  
  22.     private static int count = 0;  
  23.     private int num = count;  
  24.     public TimerTask() {  
  25.         count++;  
  26.     }  
  27.     public void execute() {  
  28.         System.out.println("[TimerTask " + num + "] start...");  
  29.         try {  
  30.             Thread.sleep(2000);  
  31.         }  
  32.         catch(InterruptedException ie) {}  
  33.         System.out.println("[TimerTask " + num + "] done.");  
  34.     }  
  35. }  
以上任务均简单的sleep若干秒。

TaskQueue实现了一个队列,客户端可以将请求放入队列,服务器线程可以从队列中取出任务:

java 代码
 
  1. package com.crackj2ee.thread;  
  2. import java.util.*;  
  3. public class TaskQueue {  
  4.     private List queue = new LinkedList();  
  5.     public synchronized Task getTask() {  
  6.         while(queue.size()==0) {  
  7.             try {  
  8.                 this.wait();  
  9.             }  
  10.             catch(InterruptedException ie) {  
  11.                 return null;  
  12.             }  
  13.         }  
  14.         return (Task)queue.remove(0);  
  15.     }  
  16.     public synchronized void putTask(Task task) {  
  17.         queue.add(task);  
  18.         this.notifyAll();  
  19.     }  
  20. }  

 

终于到了真正的WorkerThread,这是真正执行任务的服务器线程:

java 代码
  1. package com.crackj2ee.thread;  
  2. public class WorkerThread extends Thread {  
  3.     private static int count = 0;  
  4.     private boolean busy = false;  
  5.     private boolean stop = false;  
  6.     private TaskQueue queue;  
  7.     public WorkerThread(ThreadGroup group, TaskQueue queue) {  
  8.         super(group, "worker-" + count);  
  9.         count++;  
  10.         this.queue = queue;  
  11.     }  
  12.     public void shutdown() {  
  13.         stop = true;  
  14.         this.interrupt();  
  15.         try {  
  16.             this.join();  
  17.         }  
  18.         catch(InterruptedException ie) {}  
  19.     }  
  20.     public boolean isIdle() {  
  21.         return !busy;  
  22.     }  
  23.     public void run() {  
  24.         System.out.println(getName() + " start.");         
  25.         while(!stop) {  
  26.             Task task = queue.getTask();  
  27.             if(task!=null) {  
  28.                 busy = true;  
  29.                 task.execute();  
  30.                 busy = false;  
  31.             }  
  32.         }  
  33.         System.out.println(getName() + " end.");  
  34.     }  
  35. }  

前面已经讲过,queue.getTask()是一个阻塞方法,服务器线程可能在此wait()一段时间。此外,WorkerThread还有一个shutdown方法,用于安全结束线程。

 

最后是ThreadPool,负责管理所有的服务器线程,还可以动态增加和减少线程数:

java 代码
  1. package com.crackj2ee.thread;  
  2. import java.util.*;  
  3. public class ThreadPool extends ThreadGroup {  
  4.     private List threads = new LinkedList();  
  5.     private TaskQueue queue;  
  6.     public ThreadPool(TaskQueue queue) {  
  7.         super("Thread-Pool");  
  8.         this.queue = queue;  
  9.     }  
  10.     public synchronized void addWorkerThread() {  
  11.         Thread t = new WorkerThread(this, queue);  
  12.         threads.add(t);  
  13.         t.start();  
  14.     }  
  15.     public synchronized void removeWorkerThread() {  
  16.         if(threads.size()>0) {  
  17.             WorkerThread t = (WorkerThread)threads.remove(0);  
  18.             t.shutdown();  
  19.         }  
  20.     }  
  21.     public synchronized void currentStatus() {  
  22.         System.out.println("-----------------------------------------------");  
  23.         System.out.println("Thread count = " + threads.size());  
  24.         Iterator it = threads.iterator();  
  25.         while(it.hasNext()) {  
  26.             WorkerThread t = (WorkerThread)it.next();  
  27.             System.out.println(t.getName() + ": " + (t.isIdle() ? "idle" : "busy"));  
  28.         }  
  29.         System.out.println("-----------------------------------------------");  
  30.     }  
  31. }  

currentStatus()方法是为了方便调试,打印出所有线程的当前状态。

 

最后,Main负责完成main()方法:

java 代码
 
  1. package com.crackj2ee.thread;  
  2. public class Main {  
  3.     public static void main(String[] args) {  
  4.         TaskQueue queue = new TaskQueue();  
  5.         ThreadPool pool = new ThreadPool(queue);  
  6.         for(int i=0; i<10; i++) {  
  7.             queue.putTask(new CalculateTask());  
  8.             queue.putTask(new TimerTask());  
  9.         }  
  10.         pool.addWorkerThread();  
  11.         pool.addWorkerThread();  
  12.         doSleep(8000);  
  13.         pool.currentStatus();  
  14.         pool.addWorkerThread();  
  15.         pool.addWorkerThread();  
  16.         pool.addWorkerThread();  
  17.         pool.addWorkerThread();  
  18.         pool.addWorkerThread();  
  19.         doSleep(5000);  
  20.         pool.currentStatus();  
  21.     }  
  22.     private static void doSleep(long ms) {  
  23.         try {  
  24.             Thread.sleep(ms);  
  25.         }  
  26.         catch(InterruptedException ie) {}  
  27.     }  
  28. }  

 

main()一开始放入了20个Task,然后动态添加了一些服务线程,并定期打印线程状态,运行结果如下:

worker-0 start.
[CalculateTask 0] start...
worker-1 start.
[TimerTask 0] start...
[TimerTask 0] done.
[CalculateTask 1] start...
[CalculateTask 0] done.
[TimerTask 1] start...
[CalculateTask 1] done.
[CalculateTask 2] start...
[TimerTask 1] done.
[TimerTask 2] start...
[TimerTask 2] done.
[CalculateTask 3] start...
-----------------------------------------------
Thread count = 2
worker-0: busy
worker-1: busy
-----------------------------------------------
[CalculateTask 2] done.
[TimerTask 3] start...
worker-2 start.
[CalculateTask 4] start...
worker-3 start.
[TimerTask 4] start...
worker-4 start.
[CalculateTask 5] start...
worker-5 start.
[TimerTask 5] start...
worker-6 start.
[CalculateTask 6] start...
[CalculateTask 3] done.
[TimerTask 6] start...
[TimerTask 3] done.
[CalculateTask 7] start...
[TimerTask 4] done.
[TimerTask 7] start...
[TimerTask 5] done.
[CalculateTask 8] start...
[CalculateTask 4] done.
[TimerTask 8] start...
[CalculateTask 5] done.
[CalculateTask 9] start...
[CalculateTask 6] done.
[TimerTask 9] start...
[TimerTask 6] done.
[TimerTask 7] done.
-----------------------------------------------
Thread count = 7
worker-0: idle
worker-1: busy
worker-2: busy
worker-3: idle
worker-4: busy
worker-5: busy
worker-6: busy
-----------------------------------------------
[CalculateTask 7] done.
[CalculateTask 8] done.
[TimerTask 8] done.
[TimerTask 9] done.
[CalculateTask 9] done.

仔细观察:一开始只有两个服务器线程,因此线程状态都是忙,后来线程数增多,7个线程中的两个状态变成idle,说明处于wait()状态。

思考:本例的线程调度算法其实根本没有,因为这个应用是围绕TaskQueue设计的,不是以Thread Pool为中心设计的。因此,Task调度取决于TaskQueue的getTask()方法,你可以改进这个方法,例如使用优先队列,使优先级高的任务先被执行。

如果所有的服务器线程都处于busy状态,则说明任务繁忙,TaskQueue的队列越来越长,最终会导致服务器内存耗尽。因此,可以限制 TaskQueue的等待任务数,超过最大长度就拒绝处理。许多Web服务器在用户请求繁忙时就会拒绝用户:HTTP 503 SERVICE UNAVAILABLE

从JDK 5开始,java.util.concurrent包已经内置了Worker线程模式,无需我们手动编写上述代码。不过,理解Worker模式的原理非常重要。


分享到:
评论

相关推荐

    二十三种设计模式【PDF版】

    为能和大家能共同探讨"设计模式",我将自己在学习中的心得写下来,只是想帮助更多人更容易理解 GoF 的《设计模式》。由 于原著都是以C++为例, 以Java为例的设计模式基本又都以图形应用为例,而我们更关心Java在中间件等...

    Java工程师新人入门书籍推荐

    - 《深入理解Java虚拟机:JVM高级特性与最佳实践》:周志明的书,深入讲解JVM内存模型和多线程,对并发编程有较大帮助。 - 《Java EE 6 权威指南.基础篇.Basic concepts》:尽管现代开发更多依赖Spring等框架,...

    java编程思想习题及答案

    10. **设计模式**:习题可能涉及到一些常见的设计模式,如单例、工厂、观察者、装饰器等,设计模式是解决常见编程问题的通用解决方案。 通过解答这些习题,学习者不仅能巩固Java语言的基础,还能提高解决实际问题的...

    Java面试题

    Java作为一门广泛使用的编程语言,其面试题涵盖了众多的知识领域,包括基础语法、面向对象、集合框架、多线程、异常处理、IO流、网络编程、设计模式、JVM优化、数据库操作等。以下是一些Java面试中常被问到的知识点...

    抽奖软件java

    8. **设计模式**:良好的软件设计通常会运用设计模式,比如单例模式用于控制抽奖逻辑的实例化,工厂模式用于创建GUI组件,观察者模式用于更新界面状态等。 9. **程序测试**:代码已经测试并确认无误,这意味着...

    深入分析 Java I/O 的工作机制(转载)

    过滤流(FilterStream)是Java I/O中的一种设计模式,它们在已存在的流之上添加额外功能。例如,DataInputStream和DataOutputStream扩展了字节流,增加了对基本类型数据的读写支持;而BufferedInputStream和...

    Java 最常见 200+ 面试题全解析:面试必备.pdf

    9. 设计模式:总结Java中常用的23种设计模式的定义、使用场景和实现方式。 10. Spring/SpringMVC:介绍Spring框架的核心特性,包括IoC容器、AOP、事务管理、Spring MVC框架等。 11. SpringBoot/SpringCloud:...

    Java面试资料大集合

    3. **多线程** - **线程状态**:新建、运行、阻塞、等待、终止等五种状态。 - **同步机制**:synchronized关键字,wait()、notify()和notifyAll()方法,以及Lock接口。 - **并发工具类**:如CountDownLatch、...

    java事例集合1

    9. **设计模式**:可能包含一些常见设计模式的实现,如单例、工厂、观察者等。 10. **异常与日志记录**:如何有效地捕获和记录程序中的异常信息。 11. **反射机制**:用于在运行时动态获取类的信息和操控对象。 ...

    java8集合源码分析-javaLearner:java学习者

    《深入理解Java虚拟机》、《并发编程的艺术》、《Java多线程核心编程艺术》、《Java8函数式编程》、《Redis设计与实现》、《RocketMQ技术内幕》、《Spring技术内幕》、《Spring源码深度解析》、《剑指Offer》、...

    JAVA WEB 开发详解:XML+XSLT+SERVLET+JSP 深入剖析与实例应用.part2

    11.1 多线程的servlet模型 350 11.2 线程安全的servlet 351 11.2.1 变量的线程安全 351 11.2.2 属性的线程安全 360 11.3 singlethreadmodel接口 362 11.4 小结 363 11.5 思考题 363 第3部分 jsp篇 第12章 ...

    JAVA WEB 开发详解:XML+XSLT+SERVLET+JSP 深入剖析与实例应用.part3

    11.1 多线程的servlet模型 350 11.2 线程安全的servlet 351 11.2.1 变量的线程安全 351 11.2.2 属性的线程安全 360 11.3 singlethreadmodel接口 362 11.4 小结 363 11.5 思考题 363 第3部分 jsp篇 第12章 ...

    华为面试试题,很经典,转载

    【Java】在Java部分,面试可能涵盖基础语法、面向对象编程、集合框架、多线程、异常处理、IO流、JVM内存模型以及设计模式等方面。例如,可能会问到如何优化代码性能,如何处理并发问题,或者对Java 8的新特性如...

    studytoshare:Java基础 ,一个纯新手的快速入门,言简意赅,来自一个自学者的提要。参考和部分转载[http

    3.Java语言的特点简单、解释性、面向对象、健壮、动态、高性能、多线程、分布式处理、安全性、开源、结构中立、跨平台。 3大特性 (1).安全性 (2).虚拟机JVM(一次编译到处运行) (3).GC垃圾回收机制 开发环境...

    JAVA WEB 开发详解:XML+XSLT+SERVLET+JSP 深入剖析与实例应用.part4

    11.1 多线程的servlet模型 350 11.2 线程安全的servlet 351 11.2.1 变量的线程安全 351 11.2.2 属性的线程安全 360 11.3 singlethreadmodel接口 362 11.4 小结 363 11.5 思考题 363 第3部分 jsp篇 第12章 ...

    JAVA WEB 开发详解:XML+XSLT+SERVLET+JSP 深入剖析与实例应用.part5

    11.1 多线程的servlet模型 350 11.2 线程安全的servlet 351 11.2.1 变量的线程安全 351 11.2.2 属性的线程安全 360 11.3 singlethreadmodel接口 362 11.4 小结 363 11.5 思考题 363 第3部分 jsp篇 第12章 ...

    小小图片爬虫

    11. **代码结构与设计模式**:良好的代码组织和设计模式(如工厂模式、观察者模式)可以使项目更易于维护和扩展。 通过学习和实践这个【小小图片爬虫】项目,开发者不仅可以掌握HTTP请求的基本操作,还能了解到如何...

    word源码java-csdn-blogs:这是一个存储我的csdn博客的存储库

    11. 设计模式:单例、工厂、装饰器等23种设计模式的实例解析。 12. 数据库操作:SQL语言、JDBC编程、ORM框架(如Hibernate)等。 13. 测试:单元测试、集成测试,JUnit、Mockito等工具的使用。 博主可能通过Word...

    MINA文档

    过滤器链的设计模式使得功能模块化,方便代码复用和扩展。 2. **Session**:MINA中的Session代表了客户端与服务器之间的一个会话。它包含了会话状态,如连接状态、读写缓冲区、心跳机制等,同时也提供了发送和接收...

Global site tag (gtag.js) - Google Analytics