谁能说下多线程的状态有哪几种，都什么情况啊？

Java中的线程的生命周期大体可分为5种状态。

①NEW：这种情况指的是，通过New关键字创建了Thread类（或其子类）的对象

②RUNNABLE：这种情况指的是Thread类的对象调用了start()方法，
            这时的线程就等待时间片轮转到自己这，以便获得CPU；
            第二种情况是线程在处于RUNNABLE状态时并没有运行完自己的run方法，
            时间片用完之后回到RUNNABLE状态；
            还有种情况就是处于BLOCKED状态的线程结束了当前的BLOCKED状态之后重新回到RUNNABLE状态。

③RUNNING：这时的线程指的是获得CPU的RUNNABLE线程，RUNNING状态是所有线程都希望获得的状态。

④DEAD：处于RUNNING状态的线程，在执行完run方法之后，就变成了DEAD状态了。

⑤BLOCKED：这种状态指的是处于RUNNING状态的线程，出于某种原因，
           比如调用了sleep方法、等待用户输入等而让出当前的CPU给其他的线程。

1. 01.package duoxiancheng;  
   
2. 02./*
   
3. 03. * 需求：简单的卖票程序
   
4. 04. * 多个窗口同时卖票
   
5. 05. */  
   
6. 06.  
   
7. 07.  
   
8. 08.  
   
9. 09.  
   
10. 10./*创建线程的第一种方式：继承Thread ，由子类复写run方法。
    
11. 11.步骤：
    
12. 12.1，定义类继承Thread类；
    
13. 13.2，目的是复写run方法，将要让线程运行的代码都存储到run方法中；
    
14. 14.3，通过创建Thread类的子类对象，创建线程对象；
    
15. 15.4，调用线程的start方法，开启线程，并执行run方法。*/  
    
16. 16.  
    
17. 17./*class Ticket extends Thread      1 定义类继承Thread类；
    
18. 18. * {
    
19. 19.    private static int tick = 100;//加上静态 就 static主要目的是  让多个窗口 总共 只有100张票
    
20. 20.    public void run()       2，目的是复写run方法，将要让线程运行的代码都存储到run方法中
    
21. 21.    {
    
22. 22.        while(true)
    
23. 23.        {
    
24. 24.            if(tick>0)
    
25. 25.            System.out.println(Thread.currentThread().getName()+"sale: "+tick--);//买一张少一张
    
26. 26.        }
    
27. 27.    }
    
28. 28.}*/  
    
29. 29.  
    
30. 30.  
    
31. 31.  
    
32. 32.  
    
33. 33.  
    
34. 34.  
    
35. 35.  
    
36. 36.class Ticket implements Runnable      // 1，定义类实现Runable接口  
    
37. 37.{  
    
38. 38.    private static int tick = 1000;//加上静态 就 static主要目的是  让多个窗口 总共 只有100张票  
    
39. 39.    Object obj = new Object();  
    
40. 40.    public void run()        // 2，覆盖Runable接口中的run方法。  
    
41. 41.    {  
    
42. 42.        while(true) {  
    
43. 43.            synchronized (obj) //加上一个锁   由于（）需要一个对象    ，，随便 建立一个对象  obj  
    
44. 44.            {  
    
45. 45.                {  
    
46. 46.                    if (tick > 0)  
    
47. 47.                        System.out.println(Thread.currentThread().getName()  
    
48. 48.                                + "sale: " + tick--);//买一张少一张  
    
49. 49.                }  
    
50. 50.            }  
    
51. 51.        }  
    
52. 52.    }  
    
53. 53.}  
    
54. 54./*创建线程的第二种方式：实现Runable接口    必须掌握
    
55. 55. *  
    
56. 56. * 步骤：
    
57. 57. * 1，定义类实现Runable接口
    
58. 58. * 2，覆盖Runable接口中的run方法。
    
59. 59. * 3，通过Thread类建立线程对象。
    
60. 60. * 4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
    
61. 61. *      为什么要将Runnable接口的子类对象传递给构造函数。
    
62. 62. *      因为，自定义的run方法所属的对象是Runable接口的子类对象。
    
63. 63. *      所以要让线程去指定指定对象的run方法。就必须明确该run方法所属的对象
    
64. 64. *  
    
65. 65. * 5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
    
66. 66. *  
    
67. 67. *  
    
68. 68. * 实现方式 与继承方式的有什么区别呢？？？？
    
69. 69. * 实现方式好处：避免了但继承的局限性
    
70. 70. * 在定义线程时 建立使用实现方法〉〉〉〉〉
    
71. 71. *  
    
72. 72. * 两种方式区别：
    
73. 73. *  继承Thread：线程代码存放Thread子类run方法中。
    
74. 74. *  实现Runnable,线程代码存放在接口的子类run方法中。
    
75. 75. *  
    
76. 76. *  
    
77. 77. *  
    
78. 78. */  
    
79. 79. class SellTicket {  
    
80. 80.  
    
81. 81.    public static void main(String[] args) {  
    
82. 82.         
    
83. 83.        /*Ticket t1 = new Ticket();//创建了一个线程
    
84. 84.        Ticket t2 = new Ticket();//创建了一个线程
    
85. 85.        Ticket t3 = new Ticket();//创建了一个线程
    
86. 86.        Ticket t4 = new Ticket();//创建了一个线程
    
87. 87.        Ticket t5 = new Ticket();//创建了一个线程
    
88. 88.         
    
89. 89.         
    
90. 90.        t1.start();
    
91. 91.        t2.start();
    
92. 92.        t3.start();
    
93. 93.        t4.start();
    
94. 94.        t5.start();*/  
    
95. 95.         
    
96. 96.        Ticket t = new Ticket();//////* 3，通过Thread类建立线程对象。  
    
97. 97.        Thread t1 = new Thread(t);  
    
98. 98.        Thread t2 = new Thread(t);  
    
99. 99.        Thread t3 = new Thread(t);  
    
100. 100.        Thread t4 = new Thread(t);  
     
101. 101.        Thread t5 = new Thread(t);  
     
102. 102.         
     
103. 103.         
     
104. 104.        t1.start();  
     
105. 105.        t2.start();  
     
106. 106.        t3.start();  
     
107. 107.        t4.start();  
     
108. 108.        t5.start();  
     
109. 109.         
     
110. 110.    }  
     
111. 111.  
     
112. 112.}  
     

复制代码

我的个人总结  希望对你有帮助    注意  多线程  犹豫考虑代码的同步性 安全性  经常会用到synchronize 锁的功能的

线程在一定条件下，状态会发生变化。线程变化的状态转换图如下：

　　1、新建状态(New)：新创建了一个线程对象。

　　2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

　　3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。

　　4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

　　(一)、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。

　　(二)、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

　　(三)、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

　　5、死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

小小的作下解释：
1、线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了这个对象后，线程就进入了初始状态；
2、当该对象调用了start()方法，就进入可运行状态；
3、进入可运行状态后，当该对象被操作系统选中，获得CPU时间片就会进入运行状态；
4、进入运行状态后情况就比较复杂了
    4.1、run()方法或main()方法结束后，线程就进入终止状态；
    4.2、当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态（该状态既停止当前线程，但并不释放所占有的资源）。当sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片；
    4.3、线程调用了yield()方法，意思是放弃当前获得的CPU时间片，回到可运行状态，这时与其他进程处于同等竞争状态，OS有可能会接着又让这个进程进入运行状态；
   4.4、当线程刚进入可运行状态（注意，还没运行），发现将要调用的资源被synchroniza（同步），获取不到锁标记，将会立即进入锁池状态，等待获取锁标记（这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得），一旦线程获得锁标记后，就转入可运行状态，等待OS分配CPU时间片；
   4.5、当线程调用wait()方法后会进入等待队列（进入这个状态会释放所占有的所有资源，与阻塞状态不同），进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒（由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程），线程被唤醒后会进入锁池，等待获取锁标记。