java worker thread模式

转两个帖子

一个java worker thread例子http://blog.csdn.net/derekjiang/article/details/5204090

另一个java worker thread的讲解http://blog.csdn.net/derekjiang/article/details/5204090

 

 

Worker Thread Pattern的参与者：

1. Client（委托人）参与者

    Client参与者会建立Request参与者，并传给Channel参与者。

2. Channel（通路）参与者

    Channel参与者会从Client参与者获取Request参与者，传递给Worker参与者。

3. Worker（工人）参与者

    Worker参与者会从Channel参与者获取Request参与者，并执行这份工作。当工作结束之后，会去拿下一个Request参与者。

4. Request（请求）参与者

    Reqeust参与者用来表示工作。Request参与者会存放执行这份工作所需要的数据。

---------------------------------------------

控制承载量：

Worker参与者的数量是可以自由设置的。提高Worker参与者的数量，可以提高并发处理的工作量。但是如果准备的Worker参与者数量比同时间的工作量来的多，有些Worker参与者也派不上用场，没活干，还会占用内存。所以有必要配合实际软件使用的需要来调整Worker参与者的数量。

---------------------------------------------

Invocation与execution的分离：

Client参与者会发出工作请求，工作的内容以Request的形式包装起来，传递个Channel参与者。这个过程，对应于普通的方法调用来说，就相当于“评估自变量，启动方法”的操作。

另一方面，Worker参与者会使用从Channel参与者拿来的Request参与者，进行实际的操作。这个过程，对应于普通的方法调用来说，可以对应到“执行方法”的部分。

普通的方法调用的操作，“启动方法”和“执行方法”是连续进行的。当一个方法一经调用，就会马上继续执行，启动和执行是密不可分的。

在Worker Thread Pattern中，实现了“启动方法”和“执行方法”的分离。这样的好处有：

1. 提高响应性。

invocation可以继续自己前进，不用等待execution，这样能提高程序的响应性。

2. 控制实行顺序。

invocation和execution分离，execute的顺序就可以与invoke的次序无关，也就是说，我们可以对Request参与者设立优先级，控制Channel参与者传递Request给Worker参与者的顺序。

3. 可以取消和重复执行。

如果能将invocation和execution分离，那么就能做到在execute之前，把已经invoke的请求的execution取消掉。

同样，只要把Request参与者保存下来，就可以重复执行。

4. 分散处理的第一步

因为invocation和execution分离了，所以invoke和execute的操作也比较容易拆开在不同的计算机上面执行，相当于Reqeust参与者的对象，可以通过网络传送的另外一台计算机上。

------------------------------------------------

多态的Request参与者：

因为WorkerThread参与者只不过是单纯的接收Request的实例，调用Request的execute方法，

那么当我们建立Request类的子类，并将其传递给Channel，WorkerThread也应该能够正确的处理。

执行工作所需要的所有信息，都定义在Request参与者里。所以即使建立出多态的Request参与者，增加工作的种类，Channel参与者和Worker参与者都不需要进行任何修改。

------------------------------------------

实例：

Java代码  

1. public class Request {  
2.     private final String name; //  委托者  
3.     private final int number;  // 请求编号  
4.     private static final Random random = new Random();  
5.     public Request(String name, int number) {  
6.         this.name = name;  
7.         this.number = number;  
8.     }  
9.     public void execute() {  
10.         System.out.println(Thread.currentThread().getName() + " executes " + this);  
11.         try {  
12.             Thread.sleep(random.nextInt(1000));  
13.         } catch (InterruptedException e) {  
14.         }  
15.     }  
16.     public String toString() {  
17.         return "[ Request from " + name + " No." + number + " ]";  
18.     }  
19. }  

 

 

 

Java代码  

1. public class ClientThread extends Thread {  
2.     private final Channel channel;  
3.     private static final Random random = new Random();  
4.     public ClientThread(String name, Channel channel) {  
5.         super(name);  
6.         this.channel = channel;  
7.     }  
8.     public void run() {  
9.         try {  
10.             for (int i = 0; true; i++) {  
11.                 Request request = new Request(getName(), i);  
12.                 channel.putRequest(request);  
13.                 Thread.sleep(random.nextInt(1000));  
14.             }  
15.         } catch (InterruptedException e) {  
16.         }  
17.     }  
18. }  

 

 

 

Java代码  

1. public class WorkerThread extends Thread {  
2.     private final Channel channel;  
3.     public WorkerThread(String name, Channel channel) {  
4.         super(name);  
5.         this.channel = channel;  
6.     }  
7.     public void run() {  
8.         while (true) {  
9.             Request request = channel.takeRequest();  
10.             request.execute();  
11.         }  
12.     }  
13. }  

 

 

Java代码  

1. public class Channel {  
2.     private static final int MAX_REQUEST = 100;  
3.     private final Request[] requestQueue;  
4.     private int tail;  // 下一个putRequest的地方  
5.     private int head;  // 下一个takeRequest的地方  
6.     private int count; // Request的数量  
7.   
8.     private final WorkerThread[] threadPool;  
9.   
10.     public Channel(int threads) {  
11.         this.requestQueue = new Request[MAX_REQUEST];  
12.         this.head = 0;  
13.         this.tail = 0;  
14.         this.count = 0;  
15.   
16.         threadPool = new WorkerThread[threads];  
17.         for (int i = 0; i < threadPool.length; i++) {  
18.             threadPool[i] = new WorkerThread("Worker-" + i, this);  
19.         }  
20.     }  
21.     public void startWorkers() {  
22.         for (int i = 0; i < threadPool.length; i++) {  
23.             threadPool[i].start();  
24.         }  
25.     }  
26.     public synchronized void putRequest(Request request) {  
27.         while (count >= requestQueue.length) {  
28.             try {  
29.                 wait();  
30.             } catch (InterruptedException e) {  
31.             }  
32.         }  
33.         requestQueue[tail] = request;  
34.         tail = (tail + 1) % requestQueue.length;  
35.         count++;  
36.         notifyAll();  
37.     }  
38.     public synchronized Request takeRequest() {  
39.         while (count <= 0) {  
40.             try {  
41.                 wait();  
42.             } catch (InterruptedException e) {  
43.             }  
44.         }  
45.         Request request = requestQueue[head];  
46.         head = (head + 1) % requestQueue.length;  
47.         count--;  
48.         notifyAll();  
49.         return request;  
50.     }  
51. }  

 

 

Java代码  

1. public class Main {  
2.     public static void main(String[] args) {  
3.         Channel channel = new Channel(5);   // 工人线程的數量  
4.         channel.startWorkers();  
5.         new ClientThread("Alice", channel).start();  
6.         new ClientThread("Bobby", channel).start();  
7.         new ClientThread("Chris", channel).start();  
8.     }  
9. }