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

java多线程设计模式详解之三

 
阅读更多

前面谈了多线程应用程序能极大地改善用户相应。例如对于一个Web应用程序,每当一个用户请求服务器连接时,服务器就可以启动一个新线程为用户服务。
  
  然而,创建和销毁线程本身就有一定的开销,如果频繁创建和销毁线程,CPU和内存开销就不可忽略,垃圾收集器还必须负担更多的工作。因此,线程池就是为了避免频繁创建和销毁线程。
  
  每当服务器接受了一个新的请求后,服务器就从线程池中挑选一个等待的线程并执行请求处理。处理完毕后,线程并不结束,而是转为阻塞状态再次被放入线程池中。这样就避免了频繁创建和销毁线程。
  
  Worker Pattern实现了类似线程池的功能。首先定义Task接口:
  
  package com.crackj2ee.thread;
  public interface Task {
  void execute();
  }
  
  线程将负责执行execute()方法。注意到任务是由子类通过实现execute()方法实现的,线程本身并不知道自己执行的任务。它只负责运行一个耗时的execute()方法。
  
  具体任务由子类实现,我们定义了一个CalculateTask和一个TimerTask:
  
  // CalculateTask.java
  package com.crackj2ee.thread;
  public class CalculateTask implements Task {
  private static int count = 0;
  private int num = count;
  public CalculateTask() {
  count++;
  }
  public void execute() {
  System.out.println("[CalculateTask " + num + "] start...");
  try {
  Thread.sleep(3000);
  }
  catch(InterruptedException ie) {}
  System.out.println("[CalculateTask " + num + "] done.");
  }
  }
  
  // TimerTask.java
  package com.crackj2ee.thread;
  public class TimerTask implements Task {
  private static int count = 0;
  private int num = count;
  public TimerTask() {
  count++;
  }
  public void execute() {
  System.out.println("[TimerTask " + num + "] start...");
  try {
  Thread.sleep(2000);
  }
  catch(InterruptedException ie) {}
  System.out.println("[TimerTask " + num + "] done.");
  }
  }
  
  以上任务均简单的sleep若干秒。
  
  TaskQueue实现了一个队列,客户端可以将请求放入队列,服务器线程可以从队列中取出任务:
  
  package com.crackj2ee.thread;
  import java.util.*;
  public class TaskQueue {
  private List queue = new LinkedList();
  public synchronized Task getTask() {
  while(queue.size()==0) {
  try {
  this.wait();
  }
  catch(InterruptedException ie) {
  return null;
  }
  }
  return (Task)queue.remove(0);
  }
  public synchronized void putTask(Task task) {
  queue.add(task);
  this.notifyAll();
  }
  }
  
  终于到了真正的WorkerThread,这是真正执行任务的服务器线程:
  
  package com.crackj2ee.thread;
  public class WorkerThread extends Thread {
  private static int count = 0;
  private boolean busy = false;
  private bool ean stop = false;
  private TaskQueue queue;
  public WorkerThread(ThreadGroup group, TaskQueue queue) {
  super(group, "worker-" + count);
  count++;
  this.queue = queue;
  }
  public void shutdown() {
  stop = true;
  this.interrupt();
  try {
  this.join();
  }
  catch(InterruptedException ie) {}
  }
  public boolean isIdle() {
  return !busy;
  }
  public void run() {
  System.out.println(getName() + " start.");
  while(!stop) {
  Task task = queue.getTask();
  if(task!=null) {
  busy = true;
  task.execute();
  busy = false;
  }
  }
  System.out.println(getName() + " end.");
  }
  }
  
  前面已经讲过,queue.getTask()是一个阻塞方法,服务器线程可能在此wait()一段时间。此外,WorkerThread还有一个shutdown方法,用于安全结束线程。
  
  最后是ThreadPool,负责管理所有的服务器线程,还可以动态增加和减少线程数:
  
  package com.crackj2ee.thread;
  import java.util.*;
  public class ThreadPool extends ThreadGroup {
  private List threads = new LinkedList();
  private TaskQueue queue;
  public ThreadPool(TaskQueue queue) {
  super("Thread-Pool");
  this.queue = queue;
  }
  public synchronized void addWorkerThread() {
  Thread t = new WorkerThread(this, queue);
  threads.add(t);
  t.start();
  }
  public synchronized void removeWorkerThread() {
  if(threads.size()>0) {
  WorkerThread t = (WorkerThread)threads.remove(0);
  t.shutdown();
  }
  }
  public synchronized void currentStatus() {
  System.out.println("-----------------------------------------------");
  System.out.println("Thread count = " + threads.size());
  Iterator it = threads.iterator();
  while(it.hasNext()) {
  WorkerThread t = (WorkerThread)it.next();
  System.out.println(t.getName() + ": " + (t.isIdle() ? "idle" : "busy"));
  }
  System.out.println("-----------------------------------------------");
  }
  }
  
  currentStatus()方法是为了方便调试,打印出所有线程的当前状态。
  
  最后,Main负责完成main()方法:
  
  package com.crackj2ee.thread;
  public class Main {
  public static void main(String[] args) {
  TaskQueue queue = new TaskQueue();
  ThreadPool pool = new ThreadPool(queue);
  for(int i=0; i<10; i++) {
  queue.putTask(new CalculateTask());
  queue.putTask(new TimerTask());
  }
  pool .addWorkerThread();
  pool.addWorkerThread();
  doSleep(8000);
  pool.currentStatus();
  pool.addWorkerThread();
  pool.addWorkerThread();
  pool.addWorkerThread();
  pool.addWorkerThread();
  pool.addWorkerThread();
  doSleep(5000);
  pool.currentStatus();
  }
  private static void doSleep(long ms) {
  try {
  Thread.sleep(ms);
  }
  catch(InterruptedException ie) {}
  }
  }
  
  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.
  
  仔细观察:一开始只有两个服务器线程,因此线程状态都是忙,后来线程数增多。

分享到:
评论

相关推荐

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

    书中包含Java线程的介绍导读、12个重要的线程设计模式和全书总结以及丰富的附录内容。第一章相关线程设计模式的介绍,都举一反三使读者学习更有效。最后附上练习问题,让读者可以温故而知新,能快速地吸收书中的...

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

    Java多线程设计模式是...通过阅读“java多线程设计模式详解(PDF及源码)”的资料,我们可以深入了解这些知识点,并通过提供的源码加深理解,学习如何在实际项目中应用多线程设计模式,提高程序的并发性能和可维护性。

    java多线程设计模式详解

    Java多线程设计模式是Java编程中不可或缺的一部分,它涉及到如何在并发环境下高效、安全地组织代码...阅读提供的"java多线程设计模式详解.pdf"和"Java多线程设计模式源码"文件,将能更深入地理解这些模式的实际运用。

    java多线程设计模式详解(pdf版)

    java多线程设计模式,作者是:结城 浩,由 博硕文化 译。2005年4月,由中国铁道出版社出版。内附带部分源代码。

    java多线程设计模式详解+源码

    本资料包包含“java多线程设计模式详解”文档以及对应的源码,将帮助你深入理解并熟练运用Java多线程设计模式。 1. **线程的基本概念**:在Java中,线程是程序执行的最小单元,每个线程都有自己的程序计数器、...

    JAVA多线程设计模式详解

    本书“JAVA多线程设计模式详解”深入探讨了这一主题,旨在帮助开发者理解和掌握如何在Java环境中高效地使用多线程。 首先,基础内容介绍涵盖了线程的基本概念,包括进程与线程的区别,线程的创建方式,如通过实现...

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

    本压缩包文件“java多线程设计模式详解.rar”显然提供了深入探讨这一主题的详细资料。 一、线程基础 在Java中,线程是程序中的执行流,每个线程都有自己的程序计数器、虚拟机栈、本地方法栈和堆。主线程启动后,...

    JAVA设计模式与JAVA多线程设计模式详解

    在Java编程领域,设计模式和多线程设计模式是开发者必备的技能。设计模式是一种在特定情境下解决软件设计问题的通用、可复用的解决方案,而多线程设计模式则是处理并发问题的关键。本文将深入探讨这两种重要的概念,...

    《Java多线程设计模式详解》(PDF及源码)

    这本书是很经典的! 如何充分利用系统资源,如何让你的软件跑得更...该书详细阐述了JAVA多线程的设计、开发并配有测试源代码,更值得注意是将多线程设计与设计模式结合起来,供我们设计大型服务器的多线程提供了帮助。

Global site tag (gtag.js) - Google Analytics