黑马程序员技术交流社区

标题: 多线程的几种状态详细情况 [打印本页]

作者: 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