Java多线程设计模式（二）

 

 

目录(?)[-]

1. Guarded Suspension Pattern
2. Balking Pattern
3. Producer-Consumer Pattern

 

Guarded Suspension Pattern

     该模式描述的是当一个线程在执行某个操作时，但由于其他资源还没有准备好，需要等待，那么就等待资源准备好才开始自己的操作。我们直接看代码例子：

1. public class Request {
2. private Stringname;
3. public Request(String name) {
4. this.name = name;
5. }
6. public String getName() {
7. returnname;
8. }
9. @Override
10. public String toString() {
11. return"[ Request " +name +" ]";
12. }
13. }
14. public class RequestQueue {
15. final private LinkedList<request>queue = new LinkedList<request>();
16. public synchronizedvoid putRequest(Request request) {
17. this.queue.addLast(request);
18. notifyAll();
19. }
20. publicsynchronized Request getRequest() {
21. // 多线程版本的if
22. while (this.queue.size() <= 0) {
23. try {
24. wait();
25. }catch (InterruptedException e) {
26. }
27. }
28. return queue.removeFirst();
29. }
30. }
31. import java.util.Random;
32. public class ClientThreadextends Thread {
33. private Random      random;
34. private RequestQueuerequestQueue;
35. public ClientThread(RequestQueue requestQueue, String name,long seed) {
36. super(name);
37. this.requestQueue = requestQueue;
38. this.random =new Random(seed);
39. }
40. @Override
41. public void run() {
42. for (int i = 0; i < 10000; i++) {
43. Request request = new Request("No." + i);
44. System.out.println(Thread.currentThread().getName() +" requests " + request);
45. this.requestQueue.putRequest(request);
46. try {
47. Thread.sleep(this.random.nextInt(1000));
48. } catch (InterruptedException e) {
49. e.printStackTrace();
50. }
51. }
52. }
53. }
54. import java.util.Random;
55. public class ServerThreadextends Thread {
56. private Random      random;
57. private RequestQueuequeue;
58. public ServerThread(RequestQueue queue, String name,long seed) {
59. super(name);
60. this.queue = queue;
61. random =new Random(seed);
62. }
63. @Override
64. public void run() {
65. for (int i = 0; i < 10000; i++) {
66. Request request = queue.getRequest();
67. System.out.println(Thread.currentThread().getName() +" handles " + request);
68. try {
69. Thread.sleep(random.nextInt(1000));
70. } catch (InterruptedException e) {
71. }
72. }
73. }
74. }
75. public class Main {
76. public static void main(String[] args) {
77. RequestQueue queue = new RequestQueue();
78. ServerThread serverThread = new ServerThread(queue,"ServerThread", 3141592l);
79. ClientThread clientThread = new ClientThread(queue,"ClientThread", 6535897l);
80. serverThread.start();
81. clientThread.start();
82. }
83. }
84. </request></request>

这段代码的关键在 ReqeustQueue类的getReqeust()方法，在该方法中，判断队列是否小于或等于0，如果是，那么就等待队列有数据之后在进行获取 Request对象的操作，注意这里使用的是while，而非if。Single Threaded Execution Pattern 只有一个线程可以进入临界区，其他线程不能进入，进行等待；而Guarded Suspension Pattern中，线程要不要等待，由警戒条件决定。只有RequestQueue类使用到了wait/notifyAll，Guarded Suspension Pattern的实现是封闭在RequestQueue类里的。

Balking Pattern

该模式的重点是，如果一个请求的资源状态还没有准备好，那么就不进行处理，直接返
回，它与Guarded Suspension Pattern的区别在于Guarded Suspension
Pattern在警戒条件不成立时，线程等待，而Balking Pattern线程直接返回。我们来看代码实现：

1. import java.io.File;
2. import java.io.FileWriter;
3. import java.io.IOException;
4. public class Data {
5. private final Stringfilename;
6. private String      content;
7. privateboolean     changed;
8. public Data(String filename, String content) {
9. this.filename = filename;
10. this.content = content;
11. this.changed =true;
12. }
13. public synchronizedvoid change(String content) {
14. this.content = content;
15. this.changed =true;
16. }
17. publicsynchronizedvoid save() {
18. while (!this.changed) {
19. return;
20. }
21. doSave();
22. this.changed =false;
23. }
24. private void doSave() {
25. System.out.println(Thread.currentThread().getName() +"calls doSave, content = "
26. + this.content);
27. File file = new File(filename);
28. FileWriter writer = null;
29. try {
30. writer = new FileWriter(file, true);
31. writer.write(this.content);
32. } catch (IOException e) {
33. } finally {
34. if (writer !=null) {
35. try {
36. writer.close();
37. } catch (IOException e) {
38. e.printStackTrace();
39. }
40. }
41. }
42. }
43. }
44. import java.util.Random;
45. public class ChangerThreadextends Thread {
46. private Data  data;
47. private Randomrandom =new Random();
48. public ChangerThread(String name, Data data) {
49. super(name);
50. this.data = data;
51. }
52. @Override
53. public void run() {
54. int i = 0;
55. while (true) {
56. i++;
57. String content = "No." + i;
58. this.data.change(content);
59. try {
60. Thread.sleep(random.nextInt(1000));
61. } catch (InterruptedException e) {
62. }
63. this.data.save();
64. }
65. }
66. }
67. import java.util.Random;
68. public class SaverThreadextends Thread {
69. private Data  data;
70. private Randomrandom =new Random();
71. public SaverThread(String name, Data data) {
72. super(name);
73. this.data = data;
74. }
75. @Override
76. public void run() {
77. while (true) {
78. this.data.save();
79. try {
80. Thread.sleep(this.random.nextInt(1000));
81. } catch (InterruptedException e) {
82. }
83. }
84. }
85. public static void main(String[] args) {
86. Data data = new Data("data.txt","(empty)");
87. new SaverThread("SaverThread", data).start();
88. new ChangerThread("ChangerThread", data).start();
89. }
90. }

Producer-Consumer Pattern

该模式即经典的生产-消费模式。该模式在生产者和消费者之间加入一个“桥梁参与者”，以这个参与者来缓冲线程的处理速度之差。一般会有多个生产者和多个消费者。

1. import java.io.Serializable;
2. public class Data implements Serializable {
3. /**
4. *
5. */
6. private static final long serialVersionUID = 7212370995222659529L;
7. private String            name;
8. public Data(String name) {
9. this.name = name;
10. }
11. @Override
12. public String toString() {
13. return"[ Data name = " +this.name +" ]";
14. }
15. }
16. import java.util.LinkedList;
17. /**
18. * 数据传输channel，默认大小100，可以通过构造函数定制channel的大小。channel为FIFO模型
19. */
20. public class Channel {
21. private final LinkedList<data>buffer     =new LinkedList<data>();
22. private int                   bufferSize = 100;
23. public Channel() {
24. super();
25. }
26. public Channel(int channelSize) {
27. this.bufferSize = channelSize;
28. }
29. /**
30. * put数据到channel中，当channel的buffer大小大于或等于指定大小时，方法将进行等待
31. *
32. * @param data
33. */
34. public synchronizedvoid put(Data data) {
35. while (buffer.size() >=this.bufferSize) {
36. try {
37. wait();
38. } catch (InterruptedException e) {
39. }
40. }
41. this.buffer.addLast(data);
42. System.out.println(Thread.currentThread().getName() +" put data " + data);
43. notifyAll();
44. }
45. /**
46. * 从channel中获取数据，当channel中没有数据时，进行等待
47. *
48. * @return
49. */
50. public synchronized Data take() {
51. while (this.buffer.size() == 0) {
52. try {
53. wait();
54. } catch (InterruptedException e) {
55. }
56. }
57. Data data = this.buffer.removeFirst();
58. System.out.println(Thread.currentThread().getName() +" take date " + data);
59. notifyAll();
60. return data;
61. }
62. }
63. import java.util.Random;
64. public class ComsumerThreadextends Thread {
65. private Channel channel;
66. private Random  random =new Random();
67. public ComsumerThread(String name, Channel channel) {
68. super(name);
69. this.channel = channel;
70. }
71. @Override
72. public void run() {
73. while (true) {
74. this.channel.take();
75. try {
76. Thread.sleep(random.nextInt(1000));
77. } catch (InterruptedException e) {
78. }
79. }
80. }
81. }
82. import java.util.Random;
83. public class ProducerThreadextends Thread {
84. private Channel    channel;
85. private Random     random =new Random();
86. private staticintdataNo = 0;
87. public ProducerThread(String name, Channel channel) {
88. super(name);
89. this.channel = channel;
90. }
91. @Override
92. public void run() {
93. while (true) {
94. Data data = new Data("No." + nextDataNo());
95. this.channel.put(data);
96. try {
97. Thread.sleep(random.nextInt(1000));
98. } catch (InterruptedException e) {
99. }
100. }
101. }
102. public staticsynchronizedint nextDataNo() {
103. return ++dataNo;
104. }
105. }
106. public class MainThread {
107. public static void main(String[] args) {
108. int channelSize = 1000;
109. Channel channel = new Channel(channelSize);
110. ProducerThread producer1 = new ProducerThread("Producer1", channel);
111. ProducerThread producer2 = new ProducerThread("Producer2", channel);
112. ComsumerThread comsumer1 = new ComsumerThread("Comsumer1", channel);
113. ComsumerThread comsumer2 = new ComsumerThread("Comsumer2", channel);
114. ComsumerThread comsumer3 = new ComsumerThread("Comsumer3", channel);
115. producer1.start();
116. producer2.start();
117. comsumer1.start();
118. comsumer2.start();
119. comsumer3.start();
120. }
121. }
122. </data></data>

转载 http://blog.csdn.net/shenzhen_liubin/article/details/9774253