概述
最近开始强迫自己养成学习做笔记的习惯，今天重新复习了一下JAVA线程的状态，记录一下自己学习到的东西
JAVA线程状态
根据自己的理解，绘画了一张图来描述线程的状态变化
下面结合线程状态变化图进行简单讲解：
- 调用start()方法，创建线程，等待获得CPU。
- 执行同步块，多个线程竞争锁，没有获得锁的线程阻塞，等待锁的释放
- 调用Thread.sleep() 方法，线程有限期等待(如果该线程之前获得锁，锁不会被释放)
- 调用wait()方法，线程无限期等待，直到其他线程唤醒，当线程调用wait()方法时，线程进入一个阻塞队列，在后面会具体分析
- 当线程退出run()方法，线程结束，关于线程的停止在下面的小节会详细讲解。
深入wait()
前面说调用wait()方法以后，线程会进入一个阻塞队列，接下来我们一步步剖析源码去了解。
查看JDK源码，发现该方法在Object类中定义，是一个实例方法（Java中采用对象锁）：
public final void wait() throws InterruptedException {
wait(0);
}
wait()方法调用了wait(0)，该方法是一个native方法：
//The current thread must own this object's monitor.(调用该方法前，必须用于对象锁)
public final native void wait(long timeout) throws InterruptedException;
查看OpenJDK源码，openjdk\jdk\src\share\native\java\lang\Object.c
static JNINativeMethod methods[] = {
{"hashCode", "()I", (void *)&JVM_IHashCode},
{"wait", "(J)V", (void *)&JVM_MonitorWait},
{"notify", "()V", (void *)&JVM_MonitorNotify},
{"notifyAll", "()V", (void *)&JVM_MonitorNotifyAll},
{"clone", "()Ljava/lang/Object;", (void *)&JVM_Clone},
};
可以看到wait 对应的是 native 方法是JVM_MonitorWait， 继续查看JVM_MonitorWait的实现：openjdk\hotspot\src\share\vm\prims\jvm.cpp
VM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
JVMWrapper("JVM_MonitorWait");
Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
assert(obj->is_instance() || obj->is_array(), "JVM_MonitorWait must apply to an object");
JavaThreadInObjectWaitState jtiows(thread, ms != 0);
if (JvmtiExport::should_post_monitor_wait()) {
JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms);
}
ObjectSynchronizer::wait(obj, ms, THREAD);
在该方法中调用了 ObjectSynchronizer::wait(obj, ms, THREAD)方法，具体实现如下：
void ObjectSynchronizer::wait(Handle obj, jlong millis, TRAPS) {
//是否采用偏向锁
if (UseBiasedLocking) {
BiasedLocking::revoke_and_rebias(obj, false, THREAD);
assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
}
//如果wait time <0，抛出异常
if (millis < 0) {
TEVENT (wait - throw IAX) ;
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
}
//获取ObjectMonitor,调用wait()方法
ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD, obj());
DTRACE_MONITOR_WAIT_PROBE(monitor, obj(), THREAD, millis);
monitor->wait(millis, true, THREAD);
/* This dummy call is in place to get around dtrace bug 6254741. Once
that's fixed we can uncomment the following line and remove the call */
// DTRACE_MONITOR_PROBE(waited, monitor, obj(), THREAD);
dtrace_waited_probe(monitor, obj, THREAD);
}
发现最终是调用ObjectMonitor得wait()方法将线程加入阻塞队列，ObjectMonitor类定义源码位置：openjdk\hotspot\src\share\vm\runtime\objectMonitor.hpp,下面是ObjectMonitor类的部分定义(抽取了重要属性)：
friend class ObjectSynchronizer;
friend class ObjectWaiter；
volatile markOop _header; // 对象头
void* volatile _object; // backward object pointer - strong root
void * volatile _owner; // 该锁的拥有着
volatile jlong _previous_owner_tid; // 上一个拥护该锁的线程ID
ObjectWaiter * volatile _EntryList ; // 等待锁释放的线程
volatile intptr_t _waiters; // 等待线程的数量
ObjectWaiter * volatile _WaitSet; // 等待锁的线程列表,调用wait()方法，里面的线程需要等待notify()方法的调用
在ObjectMonitor中定义了_WaitSet属性，是ObjectWaiter类型的一个指针，该类表示等待锁的线程，具体的定义如下：
class ObjectWaiter : public StackObj {
public:
enum TStates { TS_UNDEF, TS_READY, TS_RUN, TS_WAIT, TS_ENTER, TS_CXQ } ;
enum Sorted { PREPEND, APPEND, SORTED } ;
ObjectWaiter * volatile _next; //前一个ObjectWaiter
ObjectWaiter * volatile _prev;//后一个ObjectWaiter
Thread* _thread; //等待的线程
jlong _notifier_tid;
ParkEvent * _event;
volatile int _notified ;
volatile TStates TState ;
Sorted _Sorted ; // List placement disposition
bool _active ; // Contention monitoring is enabled
public:
ObjectWaiter(Thread* thread);
void wait_reenter_begin(ObjectMonitor *mon);
void wait_reenter_end(ObjectMonitor *mon);
};
通过查看ObjectWaiter类的定义，得知ObjectMonitor通过一个双向链表来保存等待该锁的线程。当调用Object.wait()方法时，在JVM中会调用ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS)方法，下面时方法的具体实现：
void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
...................
// 创建ObjectWaiter,添加到_WaitSet队列中
ObjectWaiter node(Self);
node.TState = ObjectWaiter::TS_WAIT ;
Self->_ParkEvent->reset() ;
OrderAccess::fence(); // ST into Event; membar ; LD interrupted-flag
//WaitSetLock保护等待队列。通常只锁的拥有着才能访问等待队列
Thread::SpinAcquire (&_WaitSetLock, "WaitSet - add") ;
//加入等待队列，等待队列是循环双链表
AddWaiter (&node) ;
//使用的是一个简单的自旋锁
Thread::SpinRelease (&_WaitSetLock) ;
.....................
}
调用wait()方法以后线程进入等待队列，在其他线程中调用notify方法或者notifyAll()唤醒等待的队列。在JVM中，通过调用void ObjectMonitor::notify(TRAPS) 方法唤醒等待的线程。由于篇幅问题具体代码，请自行查看JDK源码。
结束线程
线程的结束其实就是结束run()方法的调用，具体有三种方案。
方案一: 通过判断变量的值结束线程，参考代码如下：
public class ThreadExample extends Thread {
private volatile boolean flag = true;
@Override
public void run() {
while (flag) {
System.out.println(".....");
}
System.out.println("sub thread end....");
}
public static void main(String[] args) throws InterruptedException {
ThreadExample example = new ThreadExample();
example.start();
Thread.sleep(1000 * 3);
System.out.println("asking thread stop.....");
example.flag = false;
Thread.sleep(1000 * 3);
System.out.println("main thread stop......");
}
}
在该程序中，通过判断一个boolean类型的变量来决定是否跳出while循环，结束run()方法的调用。
方案二: Thread.interrupt()
调用Thread实例的 interrupt() 方法，接下来该方法会调用
// Just to set the interrupt flag(该方法只是设置一个中断标志)
private native void interrupt0();
所以说， interrupt() 方法不会真正的中断一个线程，这是实在一个中断标志，在线程中判断线程标志，结束run()方法的调用。参考代码如下：
public class ThreadExample2 extends Thread {
public static void main(String[] args) throws InterruptedException {
ThreadExample2 test = new ThreadExample2();
test.start();
Thread.sleep(1000 * 3);
test.interrupt();
Thread.sleep(1000 * 3);
System.out.println("main thread end .....");
}
@Override
public void run() {
while (!Thread.currentThread().isInterrupted()) {
System.out.println(".......");
}
System.out.println("sub thread end.....");
}
}
方案三：Thread.interrupt()+变量的值判断
如果线程已经调用了Thread.sleep(）,wait()方法导致线程阻塞，线程不会去判断变量的值中断线程，在阻塞状态调用 interrupt() 会抛出一个中断信号，使得线程退出阻塞，同时清除中断标志。可以结合：Thread.interrupt()+变量的值判断实现线程的停止，参考代码如下：
class ThreadExample3 extends Thread {
volatile boolean stop = false;
public static void main(String args[]) throws Exception {
ThreadExample3 thread = new ThreadExample3();
thread.start();
Thread.sleep(3000);
System.out.println("Asking thread to stop...");
/*
* 如果线程阻塞，将不会检查此变量,调用interrupt之后，线程就可以尽早的终结被阻 塞状 态，能够检查这一变量。
*/
thread.stop = true;
/*
* 这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退 出阻 塞的状态
*/
thread.interrupt();
Thread.sleep(3000);
System.out.println("main thread end...");
System.exit(0);
}
public void run() {
while (!stop) {
System.out.println("...........");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
// 接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态
System.out.println("Thread interrupted...");
}
}
if(Thread.currentThread().isInterrupted()) {
System.out.println("-------有中断标志---------");
}else {
System.out.println("-------无中断标志---------");
}
System.out.println("Thread exiting under request...");
}
}
Ok，今天的总结完毕，跑路。。。。。。。。。
参考：http://blog.csdn.net/lirenzuo/article/details/75911548
