这种模式主要是如果对于一个警戒条件成立,那么就可以执行,如果不满足警戒条件,那么只需要返回,不做任何工作。
示例:Data类表示数据,字段content表示内容,changed字段表示是否改变,如果content改变了而没有存储,那么该字段为true,如果content没有改变或者改变了却已经存储了,那么该字段为false。
change方法改变数据,save方法保存数据,仅当changed为true时候才保存。
SaverThread是一个每隔一秒就保存一次数据的线程。
ChangeThread是一个每隔一秒改变数据并且将其保存的线程。
那么应该解决如何:当数据没有改变时,而SaveThread尝试保存数据的问题、以及当数据改变时两个线程先后尝试保存数据的问题。
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Data {
private String filename;
private String content;
private boolean changed;//修改内容后是否保存
public Data(String filename,String content){
this.filename=filename;
this.content=content;
changed=true;
}
public synchronized void chang(String s){
content=s;
changed=true;
}
public synchronized void save() throws IOException{
if(!changed)
return;
doSave();
changed=false;
}
private void doSave() throws IOException {
System.out.println(Thread.currentThread().getName()+" save "+content);
Writer writer=new FileWriter(filename);
writer.write(content);
writer.close();
}
}
import java.io.IOException;
public class SaverThread extends Thread{
private Data data;
public SaverThread(String name,Data data){
super(name);
this.data=data;
}
public void run(){
try{
while(true){
data.save();
Thread.sleep(1000);
}
}catch(IOException e){
e.printStackTrace();
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
import java.io.IOException;
import java.util.Random;
public class ChangerThread extends Thread{
private Data data;
private Random random=new Random();
public ChangerThread(String name,Data data){
super(name);
this.data=data;
}
public void run(){
try{
for(int i=0;true;i++){
data.chang("No."+i);
Thread.sleep(random.nextInt(1000));
data.save();
}
}catch(IOException e){
e.printStackTrace();
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
public class Test {
public static void main(String[] args){
Data data=new Data("data.txt","(empty)");
new ChangerThread("ChangerThread",data).start();
new SaverThread("SaverThread",data).start();
}
}
通常有两种方式表示balk的发生,一种是用boolean值,一种是用异常表示,这时会从throw中出异常而不是用return返回。
Guarded Suspension Pattern 中当警戒条件不成立时会一直等待到成立;而Balking Pattern中当警戒条件不成立时会直接balk退出。在这两种模式中有一种折中方案:在条件成立之前等待一段时间。即timeout。
obj.wait(1000);
让线程进入对象obj的等待区域暂停,并且释放obj的锁定。如果一下条件发生线程才会退出等待区域:一、被notify或者notifyAll唤醒;二、对这条线程执行interrupt方法,这是线程重新获得obj的锁定,并抛出InterruptException;三、发生了timeout,即1s钟大概过了,线程又获得obj的锁定。
public class TimeoutException extends Exception{
public TimeoutException(String smg){
super(smg);
}
}
public class Host {
private final long timeout;
private boolean ready=false;
public Host(long timeout){
this.timeout=timeout;
}
public synchronized void setExecutable(boolean ready){
this.ready=ready;
notifyAll();
}
public synchronized void execute() throws TimeoutException, InterruptedException{
long start=System.currentTimeMillis(); //开始计时
while(!ready){
long now=System.currentTimeMillis(); //现在的时间
long rest=timeout-(now-start);
if(rest<=0){
throw new TimeoutException("rest="+rest+";timeout="+timeout);
//setExecutable(true);
}
else{
wait(rest);//等待还剩下的时间,如果rest小于0呢(没有机会执行的)?
}
}
doExecute();
}
private void doExecute(){
System.out.println(Thread.currentThread().getName()+" doExecute ");
}
}
public class Main {
public static void main(String[] args){
Host host=new Host(10000);
System.out.println("Main Begin");
try {
host.execute();
} catch (TimeoutException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果;
Main Begin
TimeoutException: rest=0;timeout=10000
at Host.execute(Host.java:18)
at Main.main(Main.java:7)
synchronized没有timeout,也不能中断。synchronized块中无法设置timeout。