Java线程之线程状态的转换以及sleep和wait有什么区别

线程的状态转换是线程控制的基础。线程状态总的可以分为五大状态：分别是生、可运行、运行、等待|阻塞|睡眠、死。

 

1、新状态：线程对象已经创建，还没有在其上调用start()方法。

 

2、可运行状态：当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。当start()方法调用时，线程首先进入可运行状态，在线程运行之后或者阻塞、等待或睡眠状态回来后，也返回到可以运行状态。

 

3、运行状态：线程调度陈旭从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

 

4、等待|阻塞|睡眠状态：这是线程有资格运行时它所处的状态。实际上这是那个状态可以合为一种，

 

其共同点为：线程仍旧还活着。但是当前没有条件运行。换句话说，它是可运行的，但是如果某件事情出现，他可能返回到可运行状态。

 

5、 死亡状态：当线程的run()方法完成时就可以认为线程死去了。这个线程对象或许是活的，但是，它已经不是一个单独可执行的线程。线程一旦死亡，就不能复 生。如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

 

二、阻止线程执行

 

对于线程的阻止，考虑一下三个方面，不考虑IO阻塞的情况：

 

睡眠、等待

 

需要一个对象的锁定而被阻塞。

 

1、睡眠 sleep()

 

Thread.sleep(long millis) 和 Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程睡眠(暂停执行)，以"减慢线程"。当线程睡眠时，它入睡在某个地方，在苏醒之前不会返回到可运行状态。当睡 觉时间到期，则返回到可运行状态。

 

线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。

 

睡眠的实现：调用静态方法即可。

 

 

 

Java代码  收藏代码
  1. <span style="font-size: medium;">public void run() {  
  2.         int count = 0;  
  3.         while (true) {  
  4.             try {  
  5.                 Thread.sleep(1000);  
  6.             } catch (InterruptedException e) {  
  7.                 e.printStackTrace();  
  8.             }  
  9.             System.out.println(Thread.currentThread().getName() + ":" + (count++));  
  10.         }  
  11.     }</span>  

 

 

 

睡眠的位置：为了让其他线程有机会执行，可以将Thread.sleep()的调用放到线程run()方法之内，这样才能保证线程执行过程中会睡眠。

 

 

例如：

 

 

 

Java代码  收藏代码
  1. <span style="font-size: medium;">package com.sample.client;  
  2.   
  3. /** 
  4.  *  
  5.  * @author DYLAN 
  6.  */  
  7. public class Client implements Runnable {  
  8.   
  9.     @Override  
  10.     public void run() {  
  11.         for (int i = 0; i < 5; i++) {  
  12.             try {  
  13.                 Thread.sleep(1000);  
  14.             } catch (InterruptedException e) {  
  15.                 e.printStackTrace();  
  16.             }  
  17.             System.out.println(Thread.currentThread().getName() + ":" + i);  
  18.         }  
  19.     }  
  20.   
  21.     public static void main(String[] args) {  
  22.         Client client = new Client();  
  23.         Thread t = new Thread(client);  
  24.         t.setName("阿猫");  
  25.         t.start();  
  26.           
  27.         Thread t2 = new Thread(client);  
  28.         t2.setName("阿狗");  
  29.         t2.start();  
  30.     }  
  31. }</span>  

 

Java代码  收藏代码
  1. <span style="font-size: medium;">阿猫:0  
  2. 阿狗:0  
  3. 阿猫:1  
  4. 阿狗:1  
  5. 阿狗:2  
  6. 阿猫:2  
  7. 阿猫:3  
  8. 阿狗:3  
  9. 阿猫:4  
  10. 阿狗:4  
  11. </span>  

 

这样，线程在每次执行过程中，总会睡眠1000毫秒，只有线程睡眠了，其他的线程就有机会执行了。

 

 

 

注意：

 

a、线程睡眠是帮组所有线程获得运行机会的最好方法。

 

b、线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此，sleep（）方法不能保证该线程到期后就开始执行。

 

c、sleep()是静态方法，只能控制当前正在运行的线程。

 

 

 

2、线程的优先级和线程让步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 分配给线程的默认优先级

 

 

 3、Thread.yield()方法

 

Thread.yield() 方法作用是：暂停当前正在执行的线程对象，并执行其他线程。yield应该做的是让当前运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运 行机会。因此，使用yield的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield达到让步目的，因为让步的线程还有可能被 线程调度程序再次选中。

 

结论：yield()从未导致线程转到等待|睡眠|阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但是可能没有效果。

 

 

 

4、join()方法

 

Thread的非静态方法join()让一个线程B加入到另外一个线程A的尾部。在A执行完毕之前，B不能执行。

 

 

 

Java代码  收藏代码
  1. <span style="font-size: medium;">Client client = new Client();  
  2. Thread t = new Thread(client);  
  3. t.setName("阿猫");  
  4. t.setPriority(8);  
  5. t.start();  
  6. t.join();  
  7.           
  8. Thread t2 = new Thread(client);  
  9. t2.setName("阿狗");  
  10. t2.start();</span>  

 

 线程t执行完毕后线程t2方能执行。

 

 

小结：

 

到目前为止，线程离开运行状态的3中方法：

 

1、调用Thread.sleep()：使当前线程睡眠至少多少毫秒(尽管它可能在指定的时间之前被调度程序中断)。

 

2、调用Thread.yield():不能保障太多事情，尽管通常它会让当前运行线程回到可运行性状态，使得有相同优先级的线程有机会执行。

 

3、调用join()方法：保证当前线程停止执行，直到该线程所加入的线程完成为止，然而，如果它加入的线程没有存活，则当前线程不需要停止。

 

 

 

除了以上三种方式外，还有下面几种特殊情况可能使线程离开运行状态：

 

1、线程的run()方法正常执行完毕。

 

2、在对象上调用wait()方法(不是在线程上调用)。

 

3、线程不能在对象上获得锁定，它正试图运行该对象上的方法代码。

 

4、线程调度程序可以决定将当前运行状态移动到可运行状态，以便另一个线程获得运行机会，而不需要任何理由。

 

 

sleep和wait有什么区别：

第一种解释：

功能差不多,都用来进行线程控制,他们最大本质的区别是:sleep()不释放同步锁,wait()释放同步缩.  
  还有用法的上的不同是:sleep(milliseconds)可以用时间指定来使他自动醒过来,如果时间不到你只能调用interreput()来强行打断;wait()可以用notify()直接唤起.

第二种解释：

sleep是Thread类的静态方法。sleep的作用是让线程休眠制定的时间，在时间到达时恢复，也就是说sleep将在接到时间到达事件事恢复线程执行，例如：
try{
System.out.println("I'm going to bed");
Thread.sleep(1000);
System.out.println("I wake up");
}
catch(IntrruptedException e) {
}
wait是Object的方法，也就是说可以对任意一个对象调用wait方法，调用wait方法将会将调用者的线程挂起，直到其他线程调用同一个对象的notify方法才会重新激活调用者，例如：
//Thread 1

try{
obj.wait();//suspend thread until obj.notify() is called
}
catch(InterrputedException e) {
}

第三种解释：

这两者的施加者是有本质区别的. 
sleep()是让某个线程暂停运行一段时间,其控制范围是由当前线程决定,也就是说,在线程里面决定.好比如说,我要做的事情是 "点火->烧水->煮面",而当我点完火之后我不立即烧水,我要休息一段时间再烧.对于运行的主动权是由我的流程来控制.

而 wait(),首先,这是由某个确定的对象来调用的,将这个对象理解成一个传话的人,当这个人在某个线程里面说"暂停!",也是 thisOBJ.wait(),这里的暂停是阻塞,还是"点火->烧水->煮饭",thisOBJ就好比一个监督我的人站在我旁边,本来该线 程应该执行1后执行2,再执行3,而在2处被那个对象喊暂停,那么我就会一直等在这里而不执行3,但正个流程并没有结束,我一直想去煮饭,但还没被允许, 直到那个对象在某个地方说"通知暂停的线程启动!",也就是thisOBJ.notify()的时候,那么我就可以煮饭了,这个被暂停的线程就会从暂停处 继续执行.


其实两者都可以让线程暂停一段时间,但是本质的区别是一个线程的运行状态控制,一个是线程之间的通讯的问题

 在java.lang.Thread类中，提供了sleep()，
而java.lang.Object类中提供了wait()， notify()和notifyAll()方法来操作线程
sleep()可以将一个线程睡眠，参数可以指定一个时间。
而wait()可以将一个线程挂起，直到超时或者该线程被唤醒。
    wait有两种形式wait()和wait(milliseconds).
sleep和wait的区别有：
  1，这两个方法来自不同的类分别是Thread和Object
  2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
  3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
    任何地方使用
   synchronized(x){
      x.notify()
     //或者wait()
   }
   4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

 

 

 

 

posted @ 2013-06-18 15:54  不害怕  阅读(846)  评论(0)  编辑  收藏  举报