Java线程之线程状态的转换

一、线程状态

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

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规范不保证合理的轮换。

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

public void run() {
		int count = 0;
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + ":" + (count++));
		}
	}

 

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

例如：

package com.sample.client;

/**
 * 
 * @author DYLAN
 */
public class Client implements Runnable {

	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}

	public static void main(String[] args) {
		Client client = new Client();
		Thread t = new Thread(client);
		t.setName("阿猫");
		t.start();
		
		Thread t2 = new Thread(client);
		t2.setName("阿狗");
		t2.start();
	}
}

阿猫:0
阿狗:0
阿猫:1
阿狗:1
阿狗:2
阿猫:2
阿猫:3
阿狗:3
阿猫:4
阿狗:4

这样，线程在每次执行过程中，总会睡眠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不能执行。

 

 

Client client = new Client();
Thread t = new Thread(client);
t.setName("阿猫");
t.setPriority(8);
t.start();
t.join();
		
Thread t2 = new Thread(client);
t2.setName("阿狗");
t2.start();

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

小结：

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

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

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

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

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

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

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

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

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