java：线程的六种状态

线程的状态：一个线程只能有一次NEW状态，和TERMINATED状态
       1. NEW(新建状态)：创建后，启动前。线程就处于该状态。
       2. RUNNABLE(可运行状态)：线程正在执行代码，就处于该状态。
       3.BLOCKED(阻塞状态)：一个线程获取synchronized锁对象失败，就处于该状态。
       4. WAITING(无限等待)：一个线程获取Lock锁对象失败，就处于该状态。调用wait方法，线程也处于该状态。
       5.TIMED_WAITING(计时等待状态)：线程正在执行sleep方法，就处于该状态。
       6.TERMINATED(消亡状态)：线程把任务执行完毕后，就处于该状态。
 

---

代码示例：

public class ThreadState {
    public static void main(String[] args) {
        1: 新建一个对象,没有start 所以此时是NEW状态

  Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                System.out.println("running....");
            }
        };

     System.out.println("t1的状态是: "+t1.getState());//NEW

        2: 创建对象后,并且start启动了线程,线程用了while死循环,一直在占用cpu,所以此时是RUNNABLE状态
     

  Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                while (true) {
 
                }
            }
        };
        t2.start();

  System.out.println("t2的状态是: "+t2.getState());//RUNNABLE

        3:创建对象后,并且start启动了线程,但是代码瞬间执行完毕,cpu用完就释放了,所以是TERMINATED状态
   

     Thread t3 = new Thread("t3") {
            @Override
            public void run() {
                System.out.println("running....");
            }
        };
        t3.start();

     System.out.println("t3的状态是: "+t3.getState());//TERMINATED

        4:此线程调用了sleep方法将该线程暂时睡眠,所以又成为有时间的等待,时间一过就会恢复,所以是TIMED_WAITING 状态
     

   Thread t4 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (ThreadState.class) {
                    try {
                        Thread.sleep(99999);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t4.start();
        System.out.println("t4的状态是: "+t4.getState()); //TIMED_WAITING

         5:该线程调用了 thread2线程的join方法,但是线程2是死循环,一直不会停止,所以该线程需要等线程2执行完毕才能继续执行,又称为需要等待其他线程做出改变的动作,所以是WAITING 状态
         
     

       Thread t5 = new Thread("t5") {
            @Override
            public void run() {
                try {
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();
        System.out.println("t5的状态是: "+t5.getState());//WAITING

         6:线程6和线程4有一个共同的特点就是给ThreadState.class进行了加锁,线程4的执行时间比较长,锁被线程4掌握,这个时候线程6就会拿不到锁也就进人了BLOCKED状态
     

    
        Thread t6 = new Thread("t6") {
            @Override
            public void run() {
                synchronized (ThreadState.class) {
                    try {
                        Thread.sleep(999999);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t6.start()；
        System.out.println("t6的状态是: "+t6.getState());//BLOCKED
    }
}

几种方法的比较：

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