定义:
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模式 |
当线程执行守护方法时,若守护条件成立则执行,若不成立则等待。 | 当线程执行守护方法时,若守护条件成立则执行,若不成立则直接返回。 |
写一个有意思的代码
/* *
* 好神奇!!这居然是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这里注意:线程不能被多次调用