Java并发编程_Java线程的状态

操作系统线程的五种状态:新建, 就绪, 运行, 阻塞, 死亡
那Java线程的状态也是这五种吗?
不,
Java线程是六种状态

在Thread类的定义中是以下六种状态:

    public static final class State extends Enum {

        public static State[] values()
        {
            return (State[])$VALUES.clone();
        }

        public static State valueOf(String s)
        {
            return (State)Enum.valueOf(java/lang/Thread$State, s);
        }
		//线程状态的定义
        public static final State NEW;
        public static final State RUNNABLE;
        public static final State BLOCKED;
        public static final State WAITING;
        public static final State TIMED_WAITING;
        public static final State TERMINATED;
        
        private static final State $VALUES[];
  
       //线程状态的初始化
        static 
        {
            NEW = new State("NEW", 0);
            RUNNABLE = new State("RUNNABLE", 1);
            BLOCKED = new State("BLOCKED", 2);
            WAITING = new State("WAITING", 3);
            TIMED_WAITING = new State("TIMED_WAITING", 4);
            TERMINATED = new State("TERMINATED", 5);
            
            $VALUES = (new State[] {
                NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED
            });
        }

        private State(String s, int i)
        {
            super(s, i);
        }
    }

从源码中可以看出是以下六种状态:

Java线程状态变迁图:

分析:
线程创建后, 调用start() 方法开始运行; 当线程执行wait() 方法之后, 线程进入等待状态; 进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态, 而超时等待状态相当于在等待状态的基础上增加了超时限制, 也就是超时时间到达时将会返回到运行状态; 当线程调用同步方法时, 在没有获取到锁的情况下, 线程会进入到阻塞状态; 线程在执行Runnable的run() 方法之后会进入终止状态;
注意:
Java将操作系统中的运行的就绪两个状态合并为运行状态; 阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态, 但是阻塞在java.concurrent包中Lock接口的线程状态确实等待状态, 因为java.concurrent中的Lock接口对于阻塞的实现均使用了LockSupport类中的相关方法;

1. 初始状态

实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

2.就绪+运行中

2.1. 就绪状态

1. 就绪状态只是说你资格运行，调度程序没有挑选到你，你就永远是就绪状态。
2. 调用线程的start()方法，此线程进入就绪状态。
3. 当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
4. 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
5. 锁池里的线程拿到对象锁后，进入就绪状态。

2.2. 运行中状态
线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

3. 阻塞状态

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

4. 等待

处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。

5. 超时等待

处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

6. 终止状态

1. 当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
2. 在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

等待队列

• 调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。
• 与等待队列相关的步骤和图
  

1. 线程1获取对象A的锁，正在使用对象A。
2. 线程1调用对象A的wait()方法。
3. 线程1释放对象A的锁，并马上进入等待队列。
4. 锁池里面的对象争抢对象A的锁。
5. 线程5获得对象A的锁，进入synchronized块，使用对象A。
6. 线程5调用对象A的notifyAll()方法，唤醒所有线程，所有线程进入同步队列。若线程5调用对象A的notify()方法，则唤醒一个线程，不知道会唤醒谁，被唤醒的那个线程进入同步队列。
7. notifyAll()方法所在synchronized结束，线程5释放对象A的锁。
8. 同步队列的线程争抢对象锁，但线程1什么时候能抢到就不知道了。

同步队列状态

• 当前线程想调用对象A的同步方法时，发现对象A的锁被别的线程占有，此时当前线程进入同步队列。简言之，同步队列里面放的都是想争夺对象锁的线程。
• 当一个线程1被另外一个线程2唤醒时，1线程进入同步队列，去争夺对象锁。
• 同步队列是在同步的环境下才有的概念，一个对象对应一个同步队列。

几个方法的比较

• Thread.sleep(long millis): 一定是当前线程调用此方法，当前线程进入TIMED_WAITING状态，但不释放对象锁，millis后线程自动苏醒进入就绪状态。作用：给其它线程执行机会的最佳方式。
• Thread.yield(): 一定是当前线程调用此方法，当前线程放弃获取的CPU时间片，但不释放锁资源，由运行状态变为就绪状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。该方法与sleep()类似，只是不能由用户指定暂停多长时间。
• t.join()/t.join(long millis): 当前线程里调用其它线程t的join方法，当前线程进入WAITING/TIMED_WAITING状态，当前线程不会释放已经持有的对象锁。线程t执行完毕或者millis时间到，当前线程进入就绪状态。
• obj.wait(): 当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout时间到自动唤醒。
• obj.notify(): 唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。

所以要区分操作系统线程和Java线程. . .

参考书籍: <<Java并发编程的艺术>>