java多线程高级应用_高级应用 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 boolean 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.

仔细观察：一开始只有两个服务器线程，因此线程状态都是忙，后来线程数增多，

【责编:admin】

--------------------next---------------------