和线程状态有关的方法

1.线程生命周期

和进程一样，线程也是有生命周期的，线程生命周期要经过新建（New）、就绪（Runnable）、运行（Running）、阻塞（Bolcked）、死亡（Dead）5种状态，这些状态不总是顺序执行的，各个状态及其之间的转换要调用所需的方法来实现。线程的调度是JVM的一部分，在一个CPU的机器上，一个线程启动之后，一次只能运行一个线程，它不可能一直占着CPU运行，所以CPU需要在多个线程之间相互切换，于是线程的状态也会多次在运行、阻塞之间切换。JVM线程调度程序采用队列的形式决定实际运行哪个处于可运行状态的线程。线程状态之间的关系如下图所示。

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

就绪状态：也称可运行状态，当线程调用start方法，但是线程调度程序还没有把他选定为运行线程时线程所处的状态。这时线程调用了start( )方法，但是该线程的run( )方法还没有轮到被线程调度程序调用。这种状态的线程都在可运行池中。

运行状态：线程调用程序从运行池中选择一个线程作为当前线程时线程所处的状态，这也是线程进入运行状态的唯一方式。如果一个线程想要运行，只能从可运行状态变为运行状态。这种状态的线程是正在执行run( )方法。

阻塞状态：线程仍然是活的，但是当前没有条件运行。当等待事件出现之后它可以返回到可运行状态，等待事件通常是等待获取除调度执行需要的CPU之外的其他系统资源。这种状态的线程正处于睡眠状态，等待其他线程首先调度执行状态等。

死亡状态：当线程的run( )方法执行完毕线程就会进入死亡状态。线程一旦死去，就不能复生。

下面介绍和这些生命周期中的各个状态都用到了哪些方法，线程的状态转之间对应的方法。

2.和线程运行有关的方法

新建状态：就是在main( )方法中写入：Thread  myThread = new Thread(); 还没有执行其他操作时线程的状态。

（1）public void start( )方法：新建--->就绪

Thread.java类中的start( )方法用于启动线程，让线程从新建状态进入就绪队列排队。该方法用于通知线程调度程序此线程已准备就绪，等待安排一个时间调用该线程对象的run( )方法，也就是让线程得到运行，启动线程得到异步的效果。

一个线程只能执行一次，多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。

线程启动顺序与start( )执行顺序无关。

（2）public void run( )方法：就绪--->运行

线程对象被调度之后执行的方法，执行run( )方法的线程正处于运行状态。该方法的执行通常都是由start( )方法触发的，执行start( )方法之后，就会产生一个新的线程，结果是两个线程并发地运行；比如main( )方法调用了一个线程的start( )方法，那一个线程就是主线程，另一个线程是main( )方法中新建的线程。调用start( )方法等待线程调度程序调度，到执行run( )方法的过程中线程就从就绪状态转到了运行状态。Thread 的子类应该重写该方法。

run( )方法和start( )方法的区别和联系：

调用start( )方法的线程并不能马上得到运行，还需要被线程调度程序选中才能执行run( )方法，执行run( )方法的时候才算指正得到了执行，这时执行run( )方法的是该线程本身。如果该线程直接调用线程的run( )方法而不是由start( )方法调用，那么此线程对象并不交给线程调度程序处理，而是由main主线程调用run( )方法，这时的主线程就是同步执行而不是异步的，也就必须等待run( )方法中的代码执行完毕才能执行main( )方法后面的代码。

（3）public static void yield()：运行--->就绪

该方法是暂停当前正在执行的线程对象占有的CPU资源，让同等优先级的其他线程去占有CPU执行，关于程序优先级下面有讲。放弃CPU后，一段时间内也只能有一个线程占有CPU运行，至于放弃CPU后哪个线程能够获得CPU是随机的不确定的，放弃的时间也不确定。执行yield( )方法使线程从运行状态转到可运行状态，执行该方法有可能没有效果，无法保证yied( )达到让步的目的，因为让步的线程可能刚刚放弃，该线程马上又被线程调度程序再次选中获取CPU。

下面通过一个实例看一下执行yield( )方法的效果，首先新建一个线程类：

public class MyThread extends Thread {
	    
		@Override
                public void run(){
		long beginTime = System.currentTimeMillis();
		int count =0;
		for(int i=0;i<50000000;i++){
		//Thread.yield();
		count = count+(i+1);	
		}
		long endTime = System.currentTimeMillis();
                System.out.println("用时"+(endTime-beginTime)+"毫秒");
	        }	
		
}

在main( )方法中创建该线程类：

public class Test {

	public static void main(String[] args) {
        // TODO Auto-generated method stub
        Thread myThread = new MyThread();        
        myThread.start();
	}

}

程序运行结果：

当把//Thread.yield();这一行去掉注释符号之后，程序运行结果：

 

在没有调用yield( )方法之前，线程从开始就占据CPU运行，运行的时间很短；在调用了yield( )方法之后，线程就会在执行过程中出让一段时间的CPU资源让其他的线程运行。这里的其他线程不仅仅是Eclipse中的mian( )方法里创建的线程，还包括计算机里的其他任务。因此虽然main( )方法里面只创建了一个线程，但是该线程调用yield( )方法前后执行的时间还是有很大差距的。 

3.和线程阻塞有关的方法

处于阻塞状态的线程仍然是活的，当等待事件出现之后它可以返回到可运行状态。我们可以有一些方法让线程的状态实现和阻塞状态有关的切换。

（1）public static void sleep(long millis)

Java中通过Thread类的静态方法sleep( )来实现线程的睡眠。该方法用于暂停当前线程的执行，让当前线程休眠若干秒。因为方法是静态的，使用Thread.sleep(long millis)就可以直接调用。

线程睡眠是帮助其他线程获得运行机会的最好方法。

当线程睡眠时它暂停执行，线程调用在运行过程中调用sleep( )方法前后实现了从运行状态到阻塞状态的切换，线程睡眠到期自然苏醒，sleep( )时间到期方法运结束之后线程从阻塞状态返回到可运行状态。

sleep( )中的指定时间是线程不会运行的最短时间。因此，sleep( )方法不能保证该线程睡眠到期后就开始执行。

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

（2）public final void join()

当前线程等待调用该方法的线程结束后，再排队等待CPU资源。当前线程从运行到调用该方法的线程开始执行该方法，当前线程从运行态转为阻塞态，调用该方法的线程执行该方法结束后，当前线程从阻塞态转为就绪态。

该方法还可以加上等待该线程终止的最长时间是多少毫秒的参数。如果调用join( )方法的时候加上了时间参数，这个线程就需要等待，在规定的时间之后才能运行。假如调用join( )的线程在规定时间之内完成运行，则当前线程就不用等到规定的时间结束就可以立即有机会运行，所以才会有“等待该线程终止的最长时间”的说法。

假如现在有“A”，“B”两个线程，如果没有调用join( )方法，“A”，“B”两个线程的关系就是异步的，调用两个线程的start( )方法谁先谁后执行不确定。调用join( )方法之后可以让线程“B”加入到线程“A”的尾部，在线程“A”执行完毕之前，线程“B”不能工作，从而实现两个线程的顺序调用。线程“A”，“B”在调用join( )方法前后的关系如图：

没有调用join( )方法时的代码如下：

public class MyThreadA extends Thread {
	    
		@Override
                public void run(){
		long beginTime = System.currentTimeMillis();
		int count =0;
		for(int i=0;i<50000000;i++){
		Thread.yield();
		count = count+(i+1);	
		}
		long endTime = System.currentTimeMillis();
                System.out.println("MyThreadA开始时间："+beginTime+"，结束时间："+endTime+"MyThreadA用时"+(endTime-beginTime)+"毫秒");
	    }	
		
}

public class MyThreadB extends Thread {
	    
		@Override
                public void run(){
		long beginTime = System.currentTimeMillis();
		int count =0;
		for(int i=0;i<50000000;i++){
		Thread.yield();
		count = count+(i+1);	
		}
		long endTime = System.currentTimeMillis();
                System.out.println("MyThreadB开始时间："+beginTime+"，结束时间："+endTime+"MyThreadB用时"+(endTime-beginTime)+"毫秒");
	    }	
		
}

public class Test {

	public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyThreadA  myThreadA = new MyThreadA();        
        myThreadA.start();
        /*try {
			myThreadA.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}*/
        MyThreadB  myThreadB = new MyThreadB();        
        myThreadB.start();
	}

}

程序的执行结果：

可以看到没有调用join( )方法之前两个线程是交替执行的，无法保证执行顺序。

调用join( )方法时的代码，只需把main( )方法修改一下,去掉注释。

程序的执行结果：

可以看到线程“A”先执行，执行完了之后再执行“B”，虽然调用了start( )方法，但是他们并不是交替执行的，实现的是顺序执行的效果。

假如现在有三个线程“A”，“B”，“C”，让“A”，“B”，“C”三个线程顺序执行。那该怎么做？和上面的类似：

新建一个线程“C”内容和线程“A”、“B”差不多，然后main( )方法新增一个MyThreadB.join( )，如下：

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyThreadA  myThreadA = new MyThreadA();        
        myThreadA.start();
        try {
			myThreadA.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        MyThreadB  myThreadB = new MyThreadB();        
        myThreadB.start();
        try {
			myThreadB.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        MyThreadC  myThreadC = new MyThreadC();        
        myThreadC.start();
	}

}

程序执行结果：

假如一个线程调用了另一个线程的join( )方法，该线程必须等待调用join( )方法的线程运行结束后，自身才能运行。

因此另一种方法是在C的run( )方法中调用ThreadB.join( )使“B”先于“C”执行，就在B的run( )方法中调用ThreadA.join( )使“A”先于“B”执行，以此达到顺序执行的目的。

线程“A”的内容不变，线程“B”的内容如下，线程“C”和线程“B”类似。

public class MyThreadB extends Thread {
	    
		@Override
             public void run(){
			MyThreadA  myThreadA = new MyThreadA(); 
			myThreadA.start();
	        try {
				myThreadA.join();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		long beginTime = System.currentTimeMillis();
		int count =0;
		for(int i=0;i<50000000;i++){
		Thread.yield();
		count = count+(i+1);	
		}
		long endTime = System.currentTimeMillis();
            System.out.println("MyThreadB开始时间："+beginTime+"，结束时间："+endTime+"MyThreadB用时"+(endTime-beginTime)+"毫秒");
	    }	
		
}

main( )方法中只创建线程“C”，因为线程“A”和线程“B”都已在线程“B”和线程“C”的run( )方法中分别创建。

public class Test {

	public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyThreadC  myThreadC = new MyThreadC();        
        myThreadC.start();
	}

}

程序执行结果：

从程序执行结果可以看出，这样也可以达到程序顺序执行的效果。

（3）public final void suspend()和public final void resume()

这两个方法适合暂停线程有关的方法，suspend( )方法因为具有固有的死锁倾向已遭到反对，目前已过时停用。暂停线程意味着线程还可以恢复运行。在java多线程中，可以使用suspend( )方法暂停线程，使用resume( )方法恢复线程的执行。

suspend( )方法挂起线程。 如果线程处于活动状态则被挂起，且不再有进一步的活动，除非重新开始。

 resume( )重新开始挂起的进程。如果线程处于活动状态但被挂起，则它会在执行过程中重新开始并允许继续活动。该方法只与suspend( ) 一起使用，但suspend( ) 已经遭到反对，因此该方法也已过时停用。

3.和线程死亡有关的方法

停止线程就是线程从运行态转到死亡状态，线程一旦停止就不能再次运行。线程一旦到了停止状态，就完成了它生命周期的状态转换。停止线程是在多线程开发时很重要的技术点，掌握此技术可以对线程的停止进行有效的处理。

在Java中有3种方法可以终止正在运行的线程。

（1）线程的run( )方法正常执行完毕线程终止。

（2）stop( )方法强制终止线程。不推荐使用这种方法，该方法具有不安全性而且已过时。使用它可能造成不可预料的后果。

（3）使用interrupt( )方法中断线程。

下面介绍一些和线程停止有关的方法：

（1）public void interrupt()

大多数停止一个线程的操作使用interrupt( )，尽管方法的名称是“停止、终止”的意思，但这个方法不会停止一个正在运行的线程，还需要加入一个判断才可以完成一个线程的停止，中断线程。这个判断就是interrupted( )方法。下面是两个和interrupt( )方法有关的方法。

public static boolean interrupted()

测试当前线程是否已经中断。线程的中断状态由该方法清除，即清除状态标志。如果刚开始的线程的状态标志是true，调用该方法执行后具有将状态标志清除为false的功能。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

直接调用interrupt( )不会停止一个正在运行的线程，要想停止一个线程，调用该线程的interrupted( )方法，该方法在判断线程状态的同时会改变线程的状态，如果线程初始状态不是中断的，那么调用一次该方法之后就可以变成中断状态，以此达到中断线程的目的。

public boolean isInterrupted()

测试线程是否已经中断。线程的中断状态不受该方法的影响。调用该方法只会检测线程的状态而不会改变其状态。

关于interrupt( )方法的更多用法可以参考《Java多线程编程核心技术》--高洪岩 1.7节的内容。

（2）public final void stop()

强制线程停止执行。该方法具有不安全性而且已过时。

4.public final boolean isAlive()

测试当前线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态，线程处于正在运行或准备开始运行的状态，就认为线程是存活的。线程在开始执行之前是非活动状态，启动之后执行的过程中是活动状态，执行完毕又变成非活动状态。

5.线程的优先级

在操作系统中，线程可以划分优先级。多线程运行时，JVM的调度策略为按照优先级调度，CPU优先执行优先级较高的线程对象中的任务，级别相同时由操作系统按照时间片来分配。线程调度程序每次选择线程调度执行时优先级高的线程获取CPU执行的概率较大，一段时间内得到的CPU也就资源越多。CPU尽量将执行资源让给优先级比较高的线程。

并不是优先级高的线程获取到CPU之后就一直执行直到执行完优先级低的进程才能执行。当执行的线程都调用start( )方法后，他们之间也是交替执行的，只不过高优先级进程有更多执行的机会，同样的任务执行的时间短，有很大可能先执行完，这是体现高优先级线程优先执行的地方。

另外，优先级高的线程不一定每一次都先执行完，哪个线程获取CPU执行是一个概率事件。线程的优先级对线程的执行时间和执行的先后顺序具有不确定性和随机性。但是通常优先级高的运行的快，同一项任务可以优先运行完。

线程优先级通常表示为1-10的数字。通过setPriority( )方法设置线程优先级，通过getPriority( )方法获取线程的优先级。JDK中定义了线程的3个常用的优先级常量，线程如果不指定优先级，默认是中等优先级，因此中等优先级又叫默认优先级。这些优先级常量如下：

public final static int MIN_PRIORITY = 1;
public final static int MID_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;

然后调用Thread.MIN_PRIORITY等就可以使用这些常量，这些量通常用在设置线程的优先级中。

如果一个线程有调用它的另一个线程，那么该线程默认的优先级是创建它的执行线程的优先级，即线程的优先级具有继承性。A线程启动B线程，则B线程的优先级与A线程是一样的。比如main线程中新建一个子线程，如果main( )线程的优先级是6，那么子线程在没有指定优先级的情况下的优先级也应该是6。

6.守护线程

Java中有两种线程，一种是用户线程，一种是守护线程。

守护线程是一种特殊的线程，它存在的意义就是为非守护线程提供便利的服务的。如果非守护线程都不存在了，则守护线程就没有存在的必要了，那守护线程就会自动销毁。典型的守护线程就是垃圾收集器，它的作用就是在空闲时间回收那些不再被引用的对象从而节省内存空间提升运行效率，它是一个很称职的守护者。守护线程就像是非守护线程的“保姆”，只要JVM中任何一个非守护线程没有结束，守护线程就要工作，只有当最后一个非守护线程结束时，守护线程才能销毁。

和守护线程有关的方法：

public final boolean isDaemon()，此方法用于测试该线程是否为守护线程。

public final void setDaemon(boolean on)，此方法将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。

7.线程中的异常处理

最后值得注意的是，线程在执行相关的方法时都有可能引发中断异常，因此编写和线程有关的代码时需要使用try-catch语句块捕获异常。在调用一些需要捕获异常的方法时Eclipse都会提示需要捕获异常。捕获异常有关的示例代码如下：

try {
	Thread.sleep(100);
} catch (InterruptedException e) {
	e.printStackTrace();  
}

参考： Java多线程编程核心技术》--高洪岩 1.3，1.4，1.5，1.7，1.8，1.9，1.10，1.11