黑马程序员技术交流社区

标题: 多线程的几种状态详细情况 [打印本页]
作者: baihe    时间: 2014-3-16 22:25
标题: 多线程的几种状态详细情况
谁能说下多线程的状态有哪几种，都什么情况啊？
作者: 混蛋哥    时间: 2014-3-16 22:26
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给其他的线程。

作者: mohuancaizi    时间: 2014-3-16 22:29
  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 锁的功能的
作者: 黄飞1991    时间: 2014-3-17 14:56
线程在一定条件下，状态会发生变化。线程变化的状态转换图如下：
　　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()方法，唤醒有所线程），线程被唤醒后会进入锁池，等待获取锁标记。





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2