多个线程间肯定是需要通信的,回忆一下我们的并发编程模型里的流水线工作模式(流水线工作模式),我们的线程在遇到io阻塞的时候,肯定不能在那边一直等着,得出让自己的cpu资源,等到io完成了,再把任务交给下一个工作线程,我们试着来实现下看看。
第一种方式,共享变量的方式。
[code lang="java"]
package top.huster.thread.notify;
/**
* Created by longan.rtb on 2018/10/31.
*/
public class WaitOnlineImpl {
private static boolean finishedStatus = false;
public static void main(String[] args) {
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.print("我的工作做完了...");
synchronized(this) {
finishedStatus = true;
}
}
});
Thread thread2 = new Thread(() -> {
while (!finishedStatus) {
//not finish continue waiting
//System.out.print("....");
}
System.out.print("我可以开始我的工作了...");
});
thread2.start();
try {
Thread.sleep(1000L);
} catch (Exception e) {
System.err.print("error");
}
thread1.start();
}
}
//打印输入结果如下
我的工作做完了...我可以开始我的工作了...
[/code]
问题,这种方式有个很明显的问题,线程2一直在while循环等待状态的改变,所以cpu在空转。
通知机制。幸好,java给我们提供了其他的方法。wait、notify·、notifyAll这三个方法能够让我们做到很多事情。后面的锁的实现很多也依赖于这个,所以一定要搞清楚他们。
使用wait、notify的方式实现如下
[code]
package top.huster.thread.notify;
/**
* Created by longan.rtb on 2018/10/31.
*/
public class WaitNotify1Impl {
private final static Object bell = new Object();
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " 我的工作做完了...");
synchronized (bell) {
bell.notify();
}
});
Thread thread2 = new Thread( () -> {
synchronized (bell) {
try {
System.out.println(Thread.currentThread().getName() + " I am waiting for somethings....");
bell.wait();
} catch (Exception e) {
// do something
}
}
System.out.println(Thread.currentThread().getName() + " 我开始我的工作.....");
});
thread2.start();
try {
Thread.sleep(1);
} catch (Exception e) {
//do something
}
thread1.start();
}
}
/***
输出结果
Thread-1 I am waiting for somethings....
Thread-0 我的工作做完了...
Thread-1 我开始我的工作.....
**/
[/code]
成功的解决了空转的问题,但是我们仔细想一想会不会有问题呢?如果我们的程序先启动过了线程1,后启动了线程2,会有什么问题呢?
我们交换一下代码顺序,修改这几行代码如下
[code]
thread1.start();
try {
Thread.sleep(1);
} catch (Exception e) {
//do something
}
thread2.start();
[/code]
运行结果如下,你会发现线程会一直等待而无法结束。
[code]
Thread-0 我的工作做完了...
Thread-1 I am waiting for somethings....
[/code]
这个叫做信号丢失。也许简单的程序你不会犯错,但是程序一旦复杂,这种犯错的概率大大增加。那么如何来解决这个问题呢? 其实也很容易,我们设置一个标志位,如果已经notify了,则把这个标志位置为true,那么等待的线程如果发现标志位已经为true了,就不用wait了,修改代码如下:
[code]
package top.huster.thread.notify;
/**
* Created by longan.rtb on 2018/10/31.
*/
public class WaitNotify1Impl {
private final static Object bell = new Object();
private static boolean hasNotified = false;
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " 我的工作做完了...");
synchronized (bell) {
bell.notify();
hasNotified = true;
}
});
Thread thread2 = new Thread( () -> {
synchronized (bell) {
if (!hasNotified) {
try {
System.out.println(Thread.currentThread().getName() + " I am waiting for somethings....");
bell.wait();
} catch (Exception e) {
// do something
}
}
}
System.out.println(Thread.currentThread().getName() + " 我开始我的工作.....");
});
thread1.start();
try {
Thread.sleep(1);
} catch (Exception e) {
//do something
}
thread2.start();
}
}
/***
输出结果如下 ,两个线程又愉快的生活在了一起。
Thread-0 我的工作做完了...
Thread-1 我开始我的工作.....
**/
[/code]
是否现在就万事无忧了呢? 也不是,因为还有个问题叫,假唤醒。wait的线程在没有接收到notify的情况下,无缘无故的醒来,执行自己的逻辑。这个时候,因为依赖的notify线程并没有完成自己的工作,所以逻辑就出错了。这是我们不愿意看到的。
这个时候只需要把if的条件改成while就可以了,修改如下
[code]
Thread thread2 = new Thread( () -> {
synchronized (bell) {
while (!hasNotified) {
try {
System.out.println(Thread.currentThread().getName() + " I am waiting for somethings....");
bell.wait();
} catch (Exception e) {
// do something
}
}
}
System.out.println(Thread.currentThread().getName() + " 我开始我的工作.....");
});
[/code]
最开始我怎么也无法理解这个while替换if的妙处,因为我看到的文章并没有写任何逻辑,也就是线程没有做任何工作,我把print这个当做工作,写在while里,我想如果线程无端醒过来,不就继续执行他的工作了,而跟if和while没关系吗? 知道我把线程的实际工作从while拿出来才恍然大悟。只要标志位没有被设置为true,那么一直会在while循环里。都会执行wait逻辑,这个时候如果线程无端醒来,因为hasNotified还是false,因为又执行了一遍while逻辑,也就是再次进入wait。一直到标志位的值发生了改变,线程才有机会执行自己的逻辑。
实际的应用。我们使用wait和notify来实现一个锁试试。
[code]
package top.huster.thread.notify;
/**
* Created by longan.rtb on 2018/11/1.
*/
public class LockTest {
private int count = 0;
private Lock lock = new Lock();
public void increase() {
lock.lock();
count++;
lock.unlock();
}
class Lock {
private boolean hasLocked = false;
void lock() {
synchronized(this) {
while (hasLocked) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
hasLocked = true;
}
}
void unlock() {
hasLocked = false;
notify();
}
}
}
[/code]
分析: 要特别注意while那一段代码,这个就是我们刚刚上面讲述的内容,如果没有这个while会导致这个lock错失notify的信号的话,就永远wait下去。而如果不用while用if的话,如果遇到假唤醒就会导致同时有两个线程进入了lock锁定区域,这个也与我们想要的不符合。
View Comments (0)