多线程系列之五：Balking 模式

public class Data {

    private final String filename;
    private String content;
    private boolean changed;

    public Data(String filename, String content) {
        this.filename = filename;
        this.content = content;
        this.changed = true;
    }
    //修改了数据内容
    public synchronized void change(String newContent){
        content = newContent;
        changed = true;
    }
    //若数据修改过，则保存到文件中
    public synchronized void save() throws IOException{
        if (!changed){
            //如果没有修改，就不保存了
            return;
        }
        doSave();
        changed = false;
    }
    //将数据内容保存到文件中
    public void doSave() throws IOException{
        System.out.println(Thread.currentThread().getName()+" calls doSave, content ="+content);
        Writer writer = new FileWriter(filename);
        writer.write(content);
        writer.close();
    }
}

public class ChangerThread extends Thread{

    private final Data data;
    private final Random random = new Random();

    public ChangerThread(String name,Data data) {
        super(name);
        this.data = data;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; true; i++) {
                data.change("NO."+i);//修改数据
                Thread.sleep(random.nextInt(1000));//执行其他操作
                data.save();//显示的保存,用户自己点击保存
            }
        }catch (IOException e){
            e.printStackTrace();
        }catch (InterruptedException e){
            e.printStackTrace();
        }

    }
}

public class SaverThread extends Thread{
    private final Data data;

    public SaverThread(String name,Data data) {
        super(name);
        this.data = data;
    }

    @Override
    public void run() {
        try {
            while (true){
                data.save();//要求保存数据
                Thread.sleep(1000);//休眠约一秒
            }
        }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("ChangeThread",data).start();
        new SaverThread("SaverThread",data).start();


    }
}

public class Something{
    private boolean initialized = false;
    public synchronized void init(){
        if(initialized){
            return;        
        }
        doInit();
        initialized = true;
    
    }

    public void doInit(){
        //实际处理初始化
    }
}

//如果没有初始化，就做一次初始化动作。如果已经初始化就什么也不做。直接返回

public class Host {

    private final long timeout;//超时时间
    private boolean ready = false;//方法正常执行时为true

    public Host(long timeout){
        this.timeout = timeout;
    }

    //修改状态
    public synchronized void setExecutable(boolean on){
        ready =on;
        notifyAll();
    }
    //检查状态后在执行
    public synchronized void execute()throws InterruptedException,TimeoutException{
        long start = System.currentTimeMillis();//开始时间
        while (!ready){
            long now = System.currentTimeMillis();//当前时间
            long rest = timeout - (now -start);
　　　　　　 //在这里只要 <=0,我们就认为超时。（因为wait方法的参数为0时，就表示没有超时时间(超时时间无限长)，当传入负数时，会抛出IllegalArgumentException异常。）
            if (rest <= 0){ 
                throw new TimeoutException("now - start= "+(now-start)+", timeout = "+timeout);
            }
            wait(rest);
        }
　　　　 doExecute();
    }
    //实际的处理
    private void doExecute(){
        System.out.println(Thread.currentThread().getName()+" calls doExecute");
    }

}

/*

如果Host的方法执行时，不调用setExecutable(true)，程序就会出现超时
*/
public class Test {

    public static void main(String[] args) {
        Host host = new Host(10000);
        try {
            System.out.println("execute Begin");
            host.execute();
        }catch (TimeoutException e){
            e.printStackTrace();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}