前言
今天看源码的时候遇到这样一个场景，某线程里面的逻辑需要等待异步处理结果返回后才能继续执行。或者说想要把一个异步的操作封装成一个同步的过程。这里就用到了线程等待唤醒机制，下面具体看一下。
等待唤醒机制示例
下面代码是一个简单的线程唤醒机制示例，主要就是在Activity启动的时候初始化并start线程，线程start后会进入等待状态，在onResume方法中执行notify方法唤醒线程。通过这样的方式模拟异步唤醒线程——线程等待唤醒机制。
public class ThreadDemo extends AppCompatActivity {
private final static String TAG = ThreadDemo.class.getSimpleName();
private Object mLock = new Object();
private Thread mThread = new Thread(new Runnable() {
@Override
public void run() {
synchronized (mLock) {
Log.i(TAG,"state 1 = " + mThread.getState());
try {
mLock.wait(10 * 1000);
Log.i(TAG,"state 2 = " + mThread.getState());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.i(TAG,"state 3 = " + mThread.getState());
mThread.start();
Log.i(TAG,"state = 4 " + mThread.getState());
}
@Override
protected void onStart() {
super.onStart();
}
@Override
protected void onResume() {
super.onResume();
synchronized(mLock) {
Log.i(TAG,"state = 5 " + mThread.getState());
mLock.notify();
Log.i(TAG,"state = 6 " + mThread.getState());
}
}
@Override
protected void onPause() {
super.onPause();
Log.i(TAG,"state = 7 " + mThread.getState());
}
@Override
protected void onStop() {
super.onStop();
}
@Override
protected void onDestroy() {
super.onDestroy();
}
}Log如下：
09-11 17:31:29.577 32658-32658/com.android.peter.threaddemo I/ThreadDemo: state 3 = NEW
09-11 17:31:29.578 32658-32658/com.android.peter.threaddemo I/ThreadDemo: state = 4 RUNNABLE
09-11 17:31:29.578 32658-32695/com.android.peter.threaddemo I/ThreadDemo: state 1 = RUNNABLE
09-11 17:31:29.588 32658-32658/com.android.peter.threaddemo I/ThreadDemo: state = 5 TIMED_WAITING
09-11 17:31:29.588 32658-32658/com.android.peter.threaddemo I/ThreadDemo: state = 6 BLOCKED
09-11 17:31:29.588 32658-32695/com.android.peter.threaddemo I/ThreadDemo: state 2 = RUNNABLE
09-11 17:31:40.276 32658-32658/com.android.peter.threaddemo I/ThreadDemo: state = 7 TERMINATED为什么可以这么用
我当时看完后产生一个疑问，就是run方法的synchronized代码块不是被锁住了处于TIMED_WAITING状态了么，按理说同步锁应该没有被释放啊，为什么onResume中的synchronized代码块可以被执行从而唤醒线程。
这是因为wait是Object类的方法，当被调用时即释放资源也释放锁；而sleep是Thread类的方法，当被调用时只释放资源不释放锁。之前都是用的sleep来使线程进入TIMED_WAITING状态的，所以一直的认知是synchronized代码段执行完毕才会释放锁，然后再执行下一个synchronized代码段。经过本次学习对synchronized同步机制有了新的更深刻的认识。
java线程的状态
下面是Thread类中枚举的六种线程状态，借此机会顺便学习一下。
libcore/ojluni/src/main/java/java/lang/Thread.java
public enum State {
/**
* Thread state for a thread which has not yet started.
*/
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link #join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* is waiting for a specified thread to terminate.
*/
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}结合上面代码运行的log来理解一下线程的各个状态。
NEW（初始化状态）
线程通过new初始化完成到调用start方法前都处于等待状态。RUNNABLE（可执行状态）
线程执行start方法后就处于可以行状态。BLOCKED（阻塞状态）
notify方法被调用后线程被唤醒，但是这时notify的synchronized代码段并没有执行完，同步锁没有被释放，所以线程处于BLOCKED状态。直到notify的synchronized代码段执行完毕锁被释放，线程才回到wait所在的synchronized代码段继续执行。WAITING（等待状态）
调用sleep或是wait方法后线程处于WAITING状态，等待被唤醒。TIMED_WAITING（等待超时状态）
调用sleep或是wait方法后线程处于TIMED_WAITING状态，等待被唤醒或时间超时自动唤醒。TERMINATED（终止状态）
在run方法结束后线程处于结束状态。