JAVA多线程--线程状态

线程状态图（来源于网络）

 

线程共包括以下5种状态。
1. 新建状态(New)         : 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。
2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程；或者线程获取锁、sleep结束、join结束从而结束Blocked状态。处于就绪状态的线程，随时可以获得CPU时间片执行。
3. 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。
4. 阻塞状态(Blocked)  : 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
    (01) 等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。
    (02) 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
    (03) 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5. 死亡状态(Dead)    : 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

那jstack命令看到的堆栈信息中RUNNABLE/BLOCKED/TIMED_WAITING/WAITING状态又是怎么回事呢？（注：jstack是将在线程处于safepoint时输出线程堆栈信息，所以同一个堆栈文件打印的线程信息是不同步的，不是同一时间点的信息。）

JVM中线程状态（图片来源网络）：

    RUNNABLE 线程运行中或I/O等待

    BLOCKED 线程在等待monitor锁(synchronized关键字)，等待ReentrantLock则不会，sleep会持有锁，wait不会。

public class BlockedTest {
    public static void main(String[] args) {
        final Object lock = new Object();
        new Thread() {
            public void run() {
                synchronized (lock) {
                    try {
                        Thread.sleep(1000 * 1000);
                    } catch (InterruptedException e) {
                    }
                }
            }
        }.start();

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
        }

        synchronized (lock) {
            try {
                Thread.sleep(30 * 1000);
            } catch (InterruptedException e) {
            }
        }
    }
}

主线程BLOCKED状态

锁持有线程处于TIME_WAITING状态，等待sleep结束。

 

    TIMED_WAITING 线程在等待唤醒，但设置了时限。用Lock.tryLock(timeout, timeUnit)，这种方式也会看到TIMED_WAITING状态

public static void timedWaiting() {
      final Object lock = new Object();
      synchronized (lock) {
          try {
              lock.wait(10 * 1000);
          } catch (InterruptedException e) {
          }
     }
}

 

    WAITING 线程在无限等待唤醒，无超时的等待，必须等待lock.notify()或lock.notifyAll()或接收到interrupt信号才能退出等待状态。同理，ReentrantLock.lock()的无参方法调用，也会使线程状态变成WAITING。

public static void waiting() {
      final Object lock = new Object();
      synchronized (lock) {
          try {
                lock.wait();
           } catch (InterruptedException e) {
         }
     }
 }

public class ReentrantLockTest {

    public static void main(String[] args) {
        final ReentrantLock lock = new ReentrantLock();
        new Thread() {
            public void run() {
                lock.lock();
                try {
                    Thread.sleep(1000 * 1000);
                } catch (InterruptedException e) {
                }
                lock.unlock();
            }
        }.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
        }
        lock.lock();
    }
}