Balking模式--不需要就算了

定义：

Balking模式也有守护条件，如果守护条件不成立，立即中断处理。

引例

名字	说明
Data
SaverThread
ChangeThread
Main

public class Data {
    private String filename;    //修改是的名字
    private String content;     // 资料的内容
    private boolean changed;    //修改后的内容还没存储的话，值为true

    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) {                                           
            System.out.println(Thread.currentThread().getName() + " balks");
            return;                                             
        }                                                       
        doSave();                                             
        changed = false;                                          
    }                                                           

    // 实际资料储存到挡案里用的方法
    private 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 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);     // 休息约1秒
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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.change("No." + i);             //修改资料
                Thread.sleep(random.nextInt(1000)); // 模拟去做别的事情
                data.save();                        // 明确的要求存档
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Data data = new Data("data.txt", "(empty)");
        new ChangerThread("ChangerThread", data).start();
        new SaverThread("SaverThread", data).start();
    }
}

结果： 

SaverThread calls doSave, content = No.0
ChangerThread balks
ChangerThread calls doSave, content = No.1
SaverThread calls doSave, content = No.2
ChangerThread balks
ChangerThread calls doSave, content = No.3
ChangerThread calls doSave, content = No.4
SaverThread calls doSave, content = No.5

 Balking模式角色

GuardedObject（被守护的对象）是一个持有被守护方法的类。当线程执行守护方法时，若守护条件成立则执行，若不成立则直接返回。守护条件的成立会随着被守护的对象状态发生改变。

何时使用Balking模式

并不需要执行时、不需要等待守护条件时、守护条件仅在第一次成立时

tips：synchronized中没有超时，也不能中断

Suspension模式与Balking模式对比

Suspension模式与Balking模式对比

Suspension模式	Balking模式
当线程执行守护方法时，若守护条件成立则执行，若不成立则等待。	当线程执行守护方法时，若守护条件成立则执行，若不成立则直接返回。

写一个有意思的代码

/* *
 * 好神奇！！这居然是sleep（）
 * */
public class Something {
    public static void method(long x) throws InterruptedException {
        if (x != 0) {
            Object object = new Object();
            synchronized (object) {
                object.wait(x);
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("BEGIN");
        try {
            Something.method(3000);
        } catch (InterruptedException e) {
        }
        System.out.println("END");
    }
}

结果我就不写了，注释中有答案。obj.wait（）方法也可以传入参数，执行这句话时线程会进入obj的等待队列停止运行，并释放obj的锁。

问题思考

 

public class TestThread extends Thread {
	@Override
	public void run() {
		System.out.println("BEGIN");
		for (int i = 0; i < 10; i++) {
			System.out.print(".");
			try {
				Thread.sleep(100);
			} catch (Exception e) {
				//e.printStackTrace();
			}
		}
		System.out.println("END");
	}
}

public class Main {

	public static void main(String[] args) {
		Thread thread = new TestThread();
		while (true) {
			thread.start();
		}
	}

}

BEGIN
.Exception in thread "main" java.lang.IllegalThreadStateException: Thread is already started
    at java.lang.Thread.start(Thread.java:943)
    at cn.multithread.balking.test.Main.main(Main.java:8)
.........END

这里注意：线程不能被多次调用