Signaling via Shared Objects

一种简单的线程通信（线程间进行信号的发送）是使用共享相同的对象变量。

    public class MySignal {protected boolean hasDataToProcess = false;public synchronized boolean hasDataToProcess() {return this.hasDataToProcess;}public synchronized void setHasDataToProcess(boolean hasData) {this.hasDataToProcess = hasData;}}

多个线程必须共享同一个变量。

Busy Wait

一个线程一直在等待另外一个线程改变共享变量的为其期望值，称为 Busy Wait。

protected MySignal sharedSignal = ...
...
while(!sharedSignal.hasDataToProcess()){//do nothing... busy waiting
}

wait(),notify() and notifyAll()

Busy waiting 不是一种非常有效地利用CPU来运行等待线程，即容易造成CPU的浪费，除非等待线程所耗费的时间非常短。更好的方式waiting thread 能够sleep或者inactive当接受到等待信号时。
Java中使用wait(),notify(),notifyAll()来完成这些工作。

A thread that calls wait() on any object becomes inactive until another thread calls notify() on that object. In order to call either wait() or notify the calling thread must first obtain the lock on that object. In other words, the calling thread must call wait() or notify() from inside a synchronized block. Here is a modified version of MySignal called MyWaitNotify that uses wait() and notify().

也就是说，wait、notify、notifyAll必须加上synchronized关键字，且所对象必须是用一个对象。

    public class MyWaitNotify {MonitorObject myMonitorObject = new MonitorObject();public void doWait() {synchronized (myMonitorObject) {try {myMonitorObject.wait();} catch (InterruptedException e) {...}}}public void doNotify() {synchronized (myMonitorObject) {myMonitorObject.notify();}}}

Missed Signals

如果一个线程在调用wait时先调用了notify，容易出现信号丢失的情况，直接导致线程waiting forever

    public class MyWaitNotify2 {MonitorObject myMonitorObject = new MonitorObject();boolean wasSignalled = false;public void doWait() {synchronized (myMonitorObject) {if (!wasSignalled) {//  In fact it only calls wait() if no signal was received in between the previous doWait() call and this.try {myMonitorObject.wait();} catch (InterruptedException e) {...}}//clear signal and continue running.wasSignalled = false;}}public void doNotify() {synchronized (myMonitorObject) {wasSignalled = true;myMonitorObject.notify();}}}

Spurious Wakeups

For inexplicable reasons it is possible for threads to wake up even if notify() and notifyAll() has not been called. This is known as spurious wakeups. Wakeups without any reason.

    public class MyWaitNotify3 {MonitorObject myMonitorObject = new MonitorObject();boolean wasSignalled = false;public void doWait() {synchronized (myMonitorObject) {// 线程可能被一些未知的原因而唤醒，所以必须使用循环while (!wasSignalled) {try {myMonitorObject.wait();} catch (InterruptedException e) {...}}//clear signal and continue running.wasSignalled = false;}}public void doNotify() {synchronized (myMonitorObject) {wasSignalled = true;myMonitorObject.notify();}}}

Multiple Threads Waiting for the Same Signals

The while loop is also a nice solution if you have multiple threads waiting, which are all awakened using notifyAll(), but only one of them should be allowed to continue. Only one thread at a time will be able to obtain the lock on the monitor object, meaning only one thread can exit the wait() call and clear the wasSignalled flag. Once this thread then exits the synchronized block in the doWait() method, the other threads can exit the wait() call and check the wasSignalled member variable inside the while loop. However, this flag was cleared by the first thread waking up, so the rest of the awakened threads go back to waiting, until the next signal arrives.

Don’t call wait() on constant String’s or global objects

不要使用String类型去做锁对象，因为在编译期间很多常量String都会直接放入常量池中，被共享。

    public class MyWaitNotify{String myMonitorObject = "";boolean wasSignalled = false;public void doWait(){synchronized(myMonitorObject){while(!wasSignalled){try{myMonitorObject.wait();} catch(InterruptedException e){...}}//clear signal and continue running.wasSignalled = false;}}public void doNotify(){synchronized(myMonitorObject){wasSignalled = true;myMonitorObject.notify();}}}

Java — Thread Signaling相关推荐

(转)性能分析之-- JAVA Thread Dump 分析综述
原文链接:http://blog.csdn.net/rachel_luo/article/details/8920596 最近在做性能测试,需要对线程堆栈进行分析,在网上收集了一些资料,学习完后,将相 ...
三个实例演示 Java Thread Dump 日志分析
jstack Dump 日志文件中的线程状态 dump 文件里,值得关注的线程状态有: 死锁,Deadlock(重点关注) 执行中,Runnable 等待资源,Waiting on condition ...
各种 Java Thread State 第一分析法则
用 TDA 工具,看到大量 Java Thread State 的第一反应是: 1,线程状态为"waiting for monitor entry": 意味着它在等待进入一个临界 ...
java Thread sleep 和obj.wait，以及sychronized,minor源码
sleep()方法是Thread类里面的,主要的意义就是让当前线程停止执行,让出cpu给其他的线程,但是不会释放对象锁资源以及监控的状态,当指定的时间到了之后又会自动恢复运行状态. wait()方法是 ...
linux非守护线程一直不释放,Linux pthread 和 java thread 的是 / 非守护线程的行为
Linux pthread 和 java thread 的是 / 非守护线程的行为 pthread_xxx 的函数并没有直接提供设置一个 pthread 为守护线程的 API 而 pthread_at ...
java thread join()_Java Thread join() 的用法
Java Thread中, join() 方法是让调用该方法的主线程执行run()时暂时卡住,等run()执行完成后, 主线程再调用执行join()后面的代码.示例: class ThreadTest ...
Java Thread
Java Thread 使用Java多线程编程很容易. Java线程总是实现接口java.lang.Runnable, 一般有两种方法: 创建一个类实现接口Runnable, 创造该类的实例作为参数传 ...
java thread join()_Java中Thread.join()的使用方法
概要本文分三个部分对thread.join()进行分析: 1. join() 的示例和作用 2. join() 源码分析 3. 对网上其他分析 join() 的文章提出疑问 1. join() 的示 ...
Jvm处理Java Thread 的run方法中抛出异常的流程
Jvm处理Java Thread 的run方法中抛出异常的流程参考文章: (1)Jvm处理Java Thread 的run方法中抛出异常的流程 (2)https://www.cnblogs.com/ ...

Java — Thread Signaling