考试指导：java多线程设计模式详解之三

如前所述，多线程应用程序可以极大地改善用户响应。例如，对于一个Web应用程序，每当用户请求一个服务器连接时，服务器就可以启动一个新的线程来为用户服务。

但是，创建和销毁线程会有一定的开销。如果频繁地创建和销毁线程，CPU和内存开销就不能忽略，垃圾收集器就要承担更多的工作。因此，线程池是为了避免频繁地创建和销毁线程。

每当服务器接受一个新请求时，服务器从线程池中挑选一个等待线程，并执行请求处理。处理完成后，线程并没有结束，而是变成阻塞状态，再次被放入线程池。这避免了频繁地创建和销毁线程。

Worker模式实现了类似线程池的功能。首先定义任务接口:

package com . crack JEE . thread；
公共接口任务{
void execute()；
}

线程将负责执行execute()方法。注意，任务是由子类通过实现execute()方法来实现的，线程本身并不知道它正在执行的任务。它只负责运行耗时的execute()方法。

具体任务由子类实现。我们定义一个CalculateTask和一个timertask:

/calculate task . Java
package com . crack JEE . thread；
public class CalculateTask实现Task {
private static int count = 0；
private int num = count；
public calculate task(){
count++；
}
public void execute(){
system . out . println("[calculate task "+num+")start ... ");
试试{
thread . sleep(3000)；
}
catch(interrupted exception ie){ }
system . out . println("[calculate task "+num+")完成。);
}
}

//timertask . Java
包com . crack J2EE . thread；
公共类TimerTask实现Task {
private static int count = 0；
private int num = count；
public TimerTask(){
count++；
}
public void execute(){
system . out . println("[TimerTask "+num+")start ... ");
试试{
thread . sleep(2000)；
}
catch(interrupted exception ie){ }
system . out . println("[TimerTask "+num+")完成。);
}
}

以上任务都是简单的睡几秒钟。

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

package com . crack JEE . thread；
导入Java . util . *；
public class task queue {
private List queue = new linked List()；
公共同步任务getTask(){
while(queue . size()= = 0){
try {
this . wait()；
}
catch(interrupted exception ie){
返回null
}
}
return(Task)queue . remove(0)；
}
public synchronized void putTask(Task Task){
queue . add(Task)；
this . notifyall()；
}
}

最后我们到了真正的WorkerThread，也就是实际执行任务的服务器线程:

package com . crack JEE . thread；
公共类WorkerThread扩展线程{
private static int count = 0；
private boolean busy = false；
private布尔停止= false
私有TaskQueue队列；
public worker thread(thread group group，task queue queue){
super(group，" worker-"+count)；
count++；
this . queue = queue；
}
public void shut down(){
stop = true；
this . interrupt()；
试试{
this . join()；
}
catch(interrupted exception ie){ }
}
public boolean isIdle(){
return！忙；
}
public void run(){
system . out . println(getName()+" start。");
while(！stop){
Task Task = queue . gettask()；
if(任务！= null){
busy = true；
task . execute()；
busy = false；
}
}
system . out . println(getName()+" end。");
}
}

如前所述，queue.getTask()是一个阻塞方法，服务器线程可能会在这里等待一段时间。此外，WorkerThread有一个shutdown方法，用于安全地结束线程。

最后，ThreadPool负责管理所有服务器线程，还可以动态增减线程数量:

package com . crack JEE . thread；
导入Java . util . *；
公共类ThreadPool扩展thread group {
private List threads = new linked List()；
私有TaskQueue队列；
public Thread Pool(task 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 remove worker thread(){
if(threads . size()> 0){
worker thread t =(worker thread)threads . remove(0)；
t . shut down()；
}
}
public synchronized void current status(){
system . out . println("-")；
system . out . println(" Thread count = "+threads . size())；
Iterator it = threads . Iterator()；