您的位置: 首页  >  IT文章  >  线程的状态转换

线程的状态转换

分类: IT文章 • 2022-05-16 12:00:22

转载自：http://uule.iteye.com/blog/1100799


线程的状态转换：
     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、当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态（该状态既停止当前线程，但并不释放所占有的资源） 。当sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片；
   2、线程调用了yield()方法，意思是放弃当前获得的CPU时间片，回到可运行状态 ，这时与其他进程处于同等竞争状态，OS有可能会接着又让这个进程进入运行状态；
   3、当线程刚进入可运行状态（即就绪状态），发现将要调用的资源被synchroniza（同步），获取不到锁标记，将会立即进入锁池状态，等待获取锁标记（这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得），一旦线程获得锁标记后，就转入可运行状态，等待 OS分配CPU时间片；

        Wait()方法和notify()方法：当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去了对象的锁。当它被一个notify()方法唤醒时，等待池中的线程就被放到了锁池中。该线程从锁池中获得锁，然后回到wait()前的中断现场 。
   4、当线程调用wait()方法后会进入等待队列（进入这个状态会释放所占有的所有资源，与阻塞状态不同），进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒 ( wait(1000)时可以自动唤醒 ) （由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程），线程被唤醒后会进入锁池，等待获取锁标记。

参考：http://hi.baidu.com/guessa/blog/item/bac50223a2657942925807ab.html

 

 

调用Sleep、join时，不会释放所占用的资源，所以会进入阻塞状态；

调用Wait时，会释放所占用的资源，所以会进入等待队列。

 

1、睡眠
   Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。
 
   线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。 
   睡眠的实现：调用静态方法。
        try {
            Thread.sleep(123);
        } catch (InterruptedException e) {
            e.printStackTrace(); 
        } 
   睡眠的位置：为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠。

Java代码  线程的状态转换
  1. /** 
  2. * 一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串 
  3. */  
  4. public class MyThread extends Thread {  
  5.   
  6.     public void run() {  
  7.         for (int i = 0; i < 100; i++) {  
  8.             if ((i) % 10 == 0) {  
  9.                 System.out.println("-------" + i);  
  10.             }  
  11.             System.out.print(i);  
  12.             try {  
  13.                 Thread.sleep(1);  
  14.                 System.out.print("    线程睡眠1毫秒！ ");  
  15.             } catch (InterruptedException e) {  
  16.                 e.printStackTrace();  
  17.             }  
  18.         }  
  19.     }  
  20.   
  21.     public static void main(String[] args) {  
  22.         new MyThread().start();  
  23.     }  
  24. }   

  -------0
0    线程睡眠1毫秒！
1    线程睡眠1毫秒！
2    线程睡眠1毫秒！
3    线程睡眠1毫秒！
4    线程睡眠1毫秒！
5    线程睡眠1毫秒！
6    线程睡眠1毫秒！
7    线程睡眠1毫秒！
8    线程睡眠1毫秒！
9    线程睡眠1毫秒！
-------10
10    线程睡眠1毫秒！
11    线程睡眠1毫秒！
12    线程睡眠1毫秒！
13    线程睡眠1毫秒！
14    线程睡眠1毫秒！
15    线程睡眠1毫秒！
16    线程睡眠1毫秒！
17    线程睡眠1毫秒！
18    线程睡眠1毫秒！
19    线程睡眠1毫秒！
-------20
20    线程睡眠1毫秒！
21    线程睡眠1毫秒！
22    线程睡眠1毫秒！
23    线程睡眠1毫秒！
24    线程睡眠1毫秒！
25    线程睡眠1毫秒！
26    线程睡眠1毫秒！
27    线程睡眠1毫秒！
28    线程睡眠1毫秒！
29    线程睡眠1毫秒！
-------30

。。。

 

注意：
    1、线程睡眠是帮助所有线程获得运行机会 的最好方法。
    2、线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态 。sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。
    3、sleep()是静态方法，只能控制当前正在运行的线程。


2、join()方法    
   Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作。例如：
        Thread t = new MyThread();
        t.start();
        t.join();
另外，join()方法还有带超时限制的重载版本。 例如t.join(5000);则让线程等待5000毫秒，如果超过这个时间，则停止等待，变为可运行状态。
 
join()导致线程栈发生了变化，当然这些变化都是瞬时的。


线程的状态转换
 3、Thread.yield()方法 
   yield()是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
   在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

 

 Yield()方法是停止当前线程，让同等优先权的线程运行。如果没有同等优先权的线程，那么Yield()方法将不会起作用。 

线程的让步是通过Thread.yield()来实现的。yield()方法的作用是：暂停当前正在执行的线程对象，并执行其他线程。
 
要理解yield()，必须了解线程的优先级的概念。线程总是存在优先级，优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。当线程池中线程都具有相同的优先级，调度程序的JVM实现*选择它喜欢的线程。这时候调度程序的操作有两种可能：一是选择一个线程运行，直到它阻塞或者运行完成为止。二是时间分片，为池内的每个线程提供均等的运行机会。
 
注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。
  
设置线程的优先级：线程默认的优先级是创建它的执行线程的优先级。可以通过setPriority(int newPriority)更改线程的优先级。例如：
        Thread t = new MyThread();
        t.setPriority(8);
        t.start();
线程优先级为1~10之间的正整数，JVM从不会改变一个线程的优先级。然而，1~10之间的值是没有保证的。一些JVM可能不能识别10个不同的值，而将这些优先级进行每两个或多个合并，变成少于10个的优先级，则两个或多个优先级的线程可能被映射为一个优先级。
 
线程默认优先级是5，Thread类中有三个常量，定义线程优先级范围：
    static int MAX_PRIORITY
          线程可以具有的最高优先级。
    static int MIN_PRIORITY
          线程可以具有的最低优先级。
    static int NORM_PRIORITY
          分配给线程的默认优先级。

参考：http://lavasoft.blog.51cto.com/62575/99153

 

 

 

stop()和suspend()方法为何不推荐使用？

反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用 wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

 

 

 suspend() 和 resume() 方法：

两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。但suspend()方法很容易引起死锁问题，已经不推荐使用了。 


相关推荐