Java 线程生命周期

线程生命周期

1. 准备状态
   触发时机：使用 new 关键字创建一个线程。
   特点： 准备状态的线程不能被CPU调度。

2. 就绪状态
   特点： 就绪状态的线程才能被CPU调度，通过线程切换，获取CPU时间片的使用权。
   触发时机：

   1. 调用线程的 start()
   2. 时间片用完，即硬件设备发出中断指令，CPU进行线程切换。
   3. 线程主动调用 yield()。即：线程在等待锁的过程中，主动让出时间片
   4. 线程内部使用了锁，在没有获得锁的时候，也是在就绪状态

3. 运行状态
   触发时机：该线程获取CPU时间片的使用权后，由操作系统调用 run()
   特点：只有就绪状态下的线程才有机会获得CPU时间片使用权。

4. 阻塞状态
   阻塞状态根据触发的时机不同，可以分为：同步阻塞，等待阻塞(有限期，无限期)，其他阻塞
   特点：阻塞状态下的线程，会让出CPU时间片使用权，暂时停止运行。需要注意的是：阻塞是一件利他的事情，它让其他线程有了可以执行的机会。
   触发时机：

   1. 线程运行过程中，发出I/O请求，操作系统会主动进行线程切换，I/O完成后，线程会转入就绪状态。该触发方式下的阻塞是 其他阻塞。
   2. 线程内部使用锁，且在临界区代码内调用 wait(),释放锁，线程进入阻塞状态。调用 notify 会将线程转入就绪状态。注意：通过该方式触发的阻塞为 无限期等待
   3. 线程运行过程中，任何地方调用 thread.sleep(ms)或thread.join(ms),wait(ms)，都会进入阻塞状态，当超时后，线程进入就绪状态。该方式触发的阻塞为 有限期等待。
   4. 线程在锁池内监听锁的状态，且没有获得锁或获取锁失败，都会进入阻塞状态。该方式触发的阻塞为 同步阻塞。

5. 死亡状态
   触发时机：run() 顺利执行完毕，或者因为异常导致 run() 退出。
   特点： 死亡状态下的线程不会再复活了，内存会被GC清理掉。

特殊方法

• Thread.sleep(ms)

  将当前线程休眠，进入阻塞状态。如果线程持有锁，则不释放锁。当ms超时后，自动苏醒进入就绪状态。这是一种利他的行为，主动让出时间片，让其他就绪状态的线程有机会获得CPU时间片的使用权。

• Thread.yield()

  当前线程主动让位，让出时间片后，进入就绪状态。如果线程持有锁，则不会释放锁。《操作系统导论》中有句话来形容它的作用：“让开吧，宝贝”，它的出现是为了解决自旋锁浪费CPU的问题。

• thread.join()/join(ms)

  当前线程A内部，调用其他线程B的join(),当前线程A进入阻塞状态。如果当前线程持有锁，则不释放锁。当线程B执行完成或ms超时后，当前线程A进入就绪状态。作用：不难发现，该方法是在等待指定线程完成的操作，类似于CountdownLatch。

• obj.wait()

  当前线程持有锁，且需要在临界区内调用wait()/wait(ms),释放持有的锁，进入等待队列，状态变为阻塞状态，只能等 notify/notifyAll 或者 ms超时后，自动进入锁池队列，等拿到锁后，状态变为可运行状态。

• obj.notify()/notifyAll()

  通知在该锁对象的等待队列中的一个/所有线程，你/你们到锁池队列里面等着吧。

锁池队列和等待队列

锁池队列和等待队列中的线程都处在阻塞状态，不占用时间片。但是锁池中的线程都在监听锁的状态，且在锁可用的时候，可以通过竞争获得锁，而等待队列中的线程必须等通知或超时后，才能进入锁池队列，才有机会监听锁的状态并参与竞争。

扩展

以下两个指令摘抄至《操作系统导论》

测试与设置指令：

int TestAndSet(int *old_ptr, int new) {
	int old = *old_ptr; // fetch old value at old_ptr
	*old_ptr = new; // store 'new' into old_ptr
	return old;
}

如何用测试与设置指令实现一个自旋锁？下面是伪代码实现：

typedef struct lock_t {
	int flag;
} lock_t;
void init(lock_t *lock){
	// 0 indicates the lock is avaliable, 1 that is held
	lock->flag = 0;
}
void lock(lock_t lock){
	while(TestAndSet(&lock->flag, 1) == 1); // spin-wait(do nothing)
}
void unlock(lock_t *lock){
	lock->flag = 0;
}

分析代码：假设一个线程正在运行，调用 lock(), 没有其他线程持有锁，所以 flag=0。当原子地调用TAS(flag,1)时，设置flag=1,同时返回0。线程跳出 while 循环，获取到锁。当线程离开临界区，调用 unlock 将flag清理为0。由于测试(test旧的锁值)和设置(set新的值)是一个原子操作，所以我们保证了只有一个线程可以获得锁。

比较与交换指令：

int CompareAndSwap(int *ptr, int expect, int new){
	int actual = *ptr;
	if(actual == expect){
		*ptr = new;
	}
	return actual;
}

如何用CAS实现一个自旋锁那？与TAS除了加锁时调用不一样，其他地方一样。

void lock(*lock_t lock){
	while(CompareAndSwap(&lock->flag, 0, 1) == 1); // spin-wait(do nothing)
}

分析代码：CAS接收三个参数，第一个是锁值，第二个是期望值，第三个是满足期望后交换的新值。语义是：比较期望值与锁值，若满足期望则使用新值交换旧值。