Java多线程模式（二）
Guarded Suspension Pattern
public class Request {
private Stringname;
public Request(String name) {
this.name = name;
}
public String getName() {
returnname;
}
@Override
public String toString() {
return"[ Request " +name +" ]";
}
}
public class RequestQueue {
final private LinkedList<Request>queue = new LinkedList<Request>();
public synchronizedvoid putRequest(Request request) {
this.queue.addLast(request);
notifyAll();
}
publicsynchronized Request getRequest() {
// 多线程版本的if
while (this.queue.size() <= 0) {
try {
wait();
}catch (InterruptedException e) {
}
}
return queue.removeFirst();
}
}
import java.util.Random;
public class ClientThreadextends Thread {
private Random random;
private RequestQueuerequestQueue;
public ClientThread(RequestQueue requestQueue, String name,long seed) {
super(name);
this.requestQueue = requestQueue;
this.random =new Random(seed);
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
Request request = new Request("No." + i);
System.out.println(Thread.currentThread().getName() +" requests " + request);
this.requestQueue.putRequest(request);
try {
Thread.sleep(this.random.nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
import java.util.Random;
public class ServerThreadextends Thread {
private Random random;
private RequestQueuequeue;
public ServerThread(RequestQueue queue, String name,long seed) {
super(name);
this.queue = queue;
random =new Random(seed);
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
Request request = queue.getRequest();
System.out.println(Thread.currentThread().getName() +" handles " + request);
try {
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {
}
}
}
}
publicclass Main {
public static void main(String[] args) {
RequestQueue queue = new RequestQueue();
ServerThread serverThread = new ServerThread(queue,"ServerThread", 3141592l);
ClientThread clientThread = new ClientThread(queue,"ClientThread", 6535897l);
serverThread.start();
clientThread.start();
}
}
这段代码的关键在ReqeustQueue类的getReqeust()方法，在该方法中，判断队列是否小于或等于0，如果是，那么就等待队列有数据之后在进行获取Request对象的操作，注意这里使用的是while，而非if。Single Threaded Execution Pattern 只有一个线程可以进入临界区，其他线程不能进入，进行等待；而Guarded Suspension Pattern中，线程要不要等待，由警戒条件决定。只有RequestQueue类使用到了wait/notifyAll，Guarded Suspension Pattern的实现是封闭在RequestQueue类里的。Balking Pattern
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
publicclass Data {
private final Stringfilename;
private String content;
privateboolean changed;
public Data(String filename, String content) {
this.filename = filename;
this.content = content;
this.changed =true;
}
public synchronizedvoid change(String content) {
this.content = content;
this.changed =true;
}
publicsynchronizedvoid save() {
while (!this.changed) {
return;
}
doSave();
this.changed =false;
}
private void doSave() {
System.out.println(Thread.currentThread().getName() +"calls doSave, content = "
+ this.content);
File file = new File(filename);
FileWriter writer = null;
try {
writer = new FileWriter(file, true);
writer.write(this.content);
} catch (IOException e) {
} finally {
if (writer !=null) {
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
import java.util.Random;
public class ChangerThreadextends Thread {
private Data data;
private Randomrandom =new Random();
public ChangerThread(String name, Data data) {
super(name);
this.data = data;
}
@Override
public void run() {
int i = 0;
while (true) {
i++;
String content = "No." + i;
this.data.change(content);
try {
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {
}
this.data.save();
}
}
}
import java.util.Random;
public class SaverThreadextends Thread {
private Data data;
private Randomrandom =new Random();
public SaverThread(String name, Data data) {
super(name);
this.data = data;
}
@Override
public void run() {
while (true) {
this.data.save();
try {
Thread.sleep(this.random.nextInt(1000));
} catch (InterruptedException e) {
}
}
}
public static void main(String[] args) {
Data data = new Data("data.txt","(empty)");
new SaverThread("SaverThread", data).start();
new ChangerThread("ChangerThread", data).start();
}
}
Producer-Consumer Pattern
import java.io.Serializable;
public class Data implements Serializable {
/**
*
*/
private static final long serialVersionUID = 7212370995222659529L;
private String name;
public Data(String name) {
this.name = name;
}
@Override
public String toString() {
return"[ Data name = " +this.name +" ]";
}
}
import java.util.LinkedList;
/**
* 数据传输channel，默认大小100，可以通过构造函数定制channel的大小。channel为FIFO模型
*/
public class Channel {
private final LinkedList<Data>buffer =new LinkedList<Data>();
private int bufferSize = 100;
public Channel() {
super();
}
public Channel(int channelSize) {
this.bufferSize = channelSize;
}
/**
* put数据到channel中，当channel的buffer大小大于或等于指定大小时，方法将进行等待
*
* @param data
*/
public synchronizedvoid put(Data data) {
while (buffer.size() >=this.bufferSize) {
try {
wait();
} catch (InterruptedException e) {
}
}
this.buffer.addLast(data);
System.out.println(Thread.currentThread().getName() +" put data " + data);
notifyAll();
}
/**
* 从channel中获取数据，当channel中没有数据时，进行等待
*
* @return
*/
public synchronized Data take() {
while (this.buffer.size() == 0) {
try {
wait();
} catch (InterruptedException e) {
}
}
Data data = this.buffer.removeFirst();
System.out.println(Thread.currentThread().getName() +" take date " + data);
notifyAll();
return data;
}
}
import java.util.Random;
public class ComsumerThreadextends Thread {
private Channel channel;
private Random random =new Random();
public ComsumerThread(String name, Channel channel) {
super(name);
this.channel = channel;
}
@Override
public void run() {
while (true) {
this.channel.take();
try {
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {
}
}
}
}
import java.util.Random;
public class ProducerThreadextends Thread {
private Channel channel;
private Random random =new Random();
privatestaticintdataNo = 0;
public ProducerThread(String name, Channel channel) {
super(name);
this.channel = channel;
}
@Override
public void run() {
while (true) {
Data data = new Data("No." + nextDataNo());
this.channel.put(data);
try {
Thread.sleep(random.nextInt(1000));
} catch (InterruptedException e) {
}
}
}
publicstaticsynchronizedint nextDataNo() {
return ++dataNo;
}
}
public class MainThread {
public static void main(String[] args) {
int channelSize = 1000;
Channel channel = new Channel(channelSize);
ProducerThread producer1 = new ProducerThread("Producer1", channel);
ProducerThread producer2 = new ProducerThread("Producer2", channel);
ComsumerThread comsumer1 = new ComsumerThread("Comsumer1", channel);
ComsumerThread comsumer2 = new ComsumerThread("Comsumer2", channel);
ComsumerThread comsumer3 = new ComsumerThread("Comsumer3", channel);
producer1.start();
producer2.start();
comsumer1.start();
comsumer2.start();
comsumer3.start();
}
}