线程状态

/**
 * 线程的状态分析
 * @author aa
 *
 */
public class ThreadState {
    public static void main(String[] args) throws Exception {
        
        /**
         * 新建线程，线程为新建状态
         * jdk：至今尚未启动的线程的状态。 
         * 如果不给线程设置名称，线程的名称将会是：Thread-0，Thread-1。。。。。
         */
        ThreadDemo td = new ThreadDemo() ;
        System.out.println("新建状态：" + td.getState()) ; // 新建状态：NEW
        
        /**
         * 可运行状态：当线程有资格运行，调用start方法，线程首先进入可运行状态，
         * 可运行状态，不一定被线程调度程序运行，
         * 简单来说，调用start方法后，该线程依然是可运行状态，但未运行，
         * 存放在可运行池中，
         * 线程在运行的过程中，该线程的状态也是可运行状态
         * 
         * djk：可运行线程的线程状态。处于可运行状态的某一线程正在 Java 虚拟机中运行，
         * 但它可能正在等待操作系统中的其他资源，比如处理器。  
         */
        td.start() ;
        System.out.println("可运行状态：" + td.getState()) ; // 可运行状态：RUNNABLE
        
        /**
         * Main线程休眠100毫秒时，td线程也就调用了waitForTwoSecond()方法，
         * 指定休眠2秒后，再回到可运行状态
         * 指定等待一定时长时，休眠状态：TIMED_WAITING
         * jdk：具有指定等待时间的某一等待线程的线程状态。某一线程因为调用以下带有指定正等待时间的方法之一而处于定时等待状态： 
         * 带有超时值的 Thread.sleep （sleep必须带值）
         * 带有超时值的 Object.wait 
         * 带有超时值的 Thread.join 
         */
        Thread.sleep(100);
        System.out.println("休眠状态：" + td.getState()) ; // 具有指定等待时间的某一等待线程的线程状态。
        
        
        /**
         * 这里Main线程一共休眠2100毫秒时，td线程调用了waitLong()方法，
         * 该方法调用了wait()，使线程处于一直等待的状态
         * jdk：某一等待线程的线程状态。某一线程因为调用下列方法之一而处于等待状态： 
         * 不带超时值的 Object.wait 
         * 不带超时值的 Thread.join 
         */
        Thread.sleep(2000);
        System.out.println("等待状态：" + td.getState()) ; // 等待状态：WAITING
        
        td.interrupt() ;
        
        /**
         * 这里输出的也可能是终止状态
         * jdk：受阻塞并且正在等待监视器锁的某一线程的线程状态。处于受阻塞状态的某一线程正在等待监视器锁，
         * 以便进入一个同步的块/方法，或者在调用 Object.wait 之后再次进入同步的块/方法。
         */
        td.notifyWait() ;
        System.out.println("阻塞状态：" + td.getState()) ;
        
        /**
         * jdk：已终止线程的线程状态。线程已经结束执行。 
         */
        Thread.sleep(1000);
        System.out.println("终止状态：" + td.getState()) ;
        
        
        /**
         * 可以简单归纳为：新建 ， 可运行 ， 运行 ， 阻塞 ， 死亡
         * 
         * Thread.yeild() 让当前运行的线程回到可运行状态，让出时间给其他线程运行，但可能没用
         * jdk：暂停当前正在执行的线程对象，并执行其他线程。
         */

        
        /**
         * join()的用法
         * jdk：等待该线程终止的时间最长为 millis 毫秒。超时为 0 意味着要一直等下去。 
         * 简单来说，如下，由于td线程被Main线程所启动，td线程调用join方法后，
         * 也就是Mian线程要等到td线程运行完毕才会执行join方法后面的代码，
         * jdk的解析在这里就是将Main线程加入到了td线程的后面
         * join加参数，在这里意思就是Main线程需要等待2秒时间再继续执行join方法后面的代码，
         */
//        td.join() ;
//        td.join(2000) ;
        System.out.println("线程加入join之后") ;
    }
    
    private static class ThreadDemo extends Thread {
        @Override
        public void run() {
            try {
                // 测试join方法
//                for (int i = 0; i < 5; i++) {
//                    System.out.println(i);
//                    sleep(1000) ;
//                }
                waitForTwoSecond() ;
                waitLong() ;
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
        public synchronized void waitForTwoSecond() throws Exception {
            wait(2000) ;
        }
        
        public synchronized void waitLong() throws Exception {
            wait() ;
        }
        
        public synchronized void notifyWait() throws Exception {
            notify() ;
        }
    }
}

 

来源：https://www.cnblogs.com/Sx24kg/p/7867118.html