Java多线程初学者指南（4）：线程的生命周期

副标题#e#

与人有生老病死一样，线程也同样要经验开始（期待）、运行、挂起和遏制四种差异的状态。这四种状态都可以通过Thread类中的要领举办节制。下面给出了Thread类中和这四种状态相关的要领。

//　开始线程
public　void　start(　);
public　void　run(　);

//　挂起和叫醒线程
public　void　resume(　);　　//　不发起利用
public　void　suspend(　);　//　不发起利用
public　static　void　sleep(long　millis);
public　static　void　sleep(long　millis,　int　nanos);

//　终止线程
public　void　stop(　);　//　不发起利用
public　void　interrupt(　);
//　获得线程状态
public　boolean　isAlive(　);
public　boolean　isInterrupted(　);
public　static　boolean　interrupted(　);

//　join要领
public　void　join(　)　throws　InterruptedException;

一、建设并运行线程

线程在成立后并不顿时执行run要领中的代码，而是处于期待状态。线程处于期待状态时，可以通过Thread类的要领来配置线程不各类属性，如线程的优先级（setPriority）、线程名(setName)和线程的范例（setDaemon）等。

当挪用start要领后，线程开始执行run要领中的代码。线程进入运行状态。可以通过Thread类的isAlive要领来判定线程是否处于运行状态。当线程处于运行状态时，isAlive返回true，当isAlive返回false时，大概线程处于期待状态，也大概处于遏制状态。下面的代码演示了线程的建设、运行和遏制三个状态之间的切换，并输出了相应的isAlive返回值。

package　chapter2;

public　class　LifeCycle　extends　Thread
{
　public　void　run()
　{
　　int　n　=　0;
　　while　((++n)　<　1000);
　}

　public　static　void　main(String[]　args)　throws　Exception
　{
　　LifeCycle　thread1　=　new　LifeCycle();
　　System.out.println("isAlive:　"　+　thread1.isAlive());
　　thread1.start();
　　System.out.println("isAlive:　"　+　thread1.isAlive());
　　thread1.join();　　//　等线程thread1竣事后再继承执行
　　System.out.println("thread1已经竣事!");
　　System.out.println("isAlive:　"　+　thread1.isAlive());
　}
}

要留意一下，在上面的代码中利用了join要领，这个要领的主要成果是担保线程的run要领完成后措施才继承运行，这个要领将在后头的文章中先容

上面代码的运行功效：

isAlive:　false
isAlive:　true
thread1已经竣事!
isAlive:　false

#p#副标题#e#

二、挂起和叫醒线程

一但线程开始执行run要领，就会一直到这个run要领执行完成这个线程才退出。但在线程执行的进程中，可以通过两个要领使线程临时遏制执行。这两个要领是suspend和sleep。在利用suspend挂起线程后，可以通过resume要领叫醒线程。而利用sleep使线程休眠后，只能在设定的时间后使线程处于停当状态（在线程休眠竣事后，线程不必然会顿时执行，只是进入了停当状态，期待着系统举办调治）。

固然suspend和resume可以很利便地使线程挂起和叫醒，但由于利用这两个要领大概会造成一些不行预料的工作产生，因此，这两个要领被标识为deprecated(抗议)标志，这表白在今后的jdk版本中这两个要领大概被删除，所以只管不要利用这两个要领来操纵线程。下面的代码演示了sleep、suspend和resume三个要领的利用。

package　chapter2;

public　class　MyThread　extends　Thread
{
　class　SleepThread　extends　Thread
　{
　　public　void　run()
　　{
　　　try
　　　{
　　　　sleep(2000);
　　　}
　　　catch　(Exception　e)
　　　{
　　　}
　　}
　}
　public　void　run()
　{
　　while　(true)
　　System.out.println(new　java.util.Date().getTime());
　}
　public　static　void　main(String[]　args)　throws　Exception
　{
　　MyThread　thread　=　new　MyThread();
　　SleepThread　sleepThread　=　thread.new　SleepThread();
　　sleepThread.start();　//　开始运行线程sleepThread
　　sleepThread.join();　　//　使线程sleepThread延迟2秒
　　thread.start();
　　boolean　flag　=　false;
　　while　(true)
　　{
　　　sleep(5000);　　//　使主线程延迟5秒
　　　flag　=　!flag;
　　　if　(flag)
　　　　thread.suspend();
　　　else
　　　　thread.resume();
　　}
　}
}

#p#分页标题#e#

从外貌上看，利用sleep和suspend所发生的结果雷同，但sleep要领并不等同于suspend。它们之间最大的一个区别是可以在一个线程中通过suspend要领来挂起别的一个线程，如上面代码中在主线程中挂起了thread线程。而sleep只对当前正在执行的线程起浸染。在上面代码中别离使sleepThread和主线程休眠了2秒和5秒。在利用sleep时要留意，不能在一个线程中来休眠另一个线程。如main要领中利用thread.sleep(2000)要领是无法使thread线程休眠2秒的，而只能使主线程休眠2秒。

在利用sleep要领时有两点需要留意：

1.sleep要领有两个重载形式，个中一个重载形式不只可以设毫秒，并且还可以设纳秒(1,000,000纳秒便是1毫秒)。但大大都操纵系统平台上的Java虚拟机都无法准确到纳秒，因此，假如对sleep配置了纳秒，Java虚拟机将取最靠近这个值的毫秒。

2.在利用sleep要领时必需利用throws或try{…}catch{…}。因为run要领无法利用throws，所以只能利用try{…}catch{…}。当在线程休眠的进程中，利用interrupt要领（这个要领将在2.3.3中接头）间断线程时sleep会抛出一个InterruptedException异常。sleep要领的界说如下：

public　static　void　sleep(long　millis)　　throws　InterruptedException
public　static　void　sleep(long　millis,　　int　nanos)　　throws　InterruptedException

#p#副标题#e#

三、终止线程的三种要领

有三种要领可以使终止线程。

1.利用退出符号，使线程正常退出，也就是当run要领完成后线程终止。

2.利用stop要领强行终止线程（这个要领不推荐利用，因为stop和suspend、resume一样，也大概产生不行预料的功效）。

3.利用interrupt要领间断线程。　

1.利用退出符号终止线程

当run要领执行完后，线程就会退出。但有时run要领是永远不会竣事的。如在处事端措施中利用线程举办监听客户端请求，或是其他的需要轮回处理惩罚的任务。在这种环境下，一般是将这些任务放在一个轮回中，如while轮回。假如想让轮回永远运行下去，可以利用while(true){…}来处理惩罚。但要想使while轮回在某一特定条件下退出，最直接的要领就是设一个boolean范例的符号，并通过配置这个符号为true或false来节制while轮回是否退出。下面给出了一个操作退出符号终止线程的例子。

package　chapter2;

public　class　ThreadFlag　extends　Thread
{
　public　volatile　boolean　exit　=　false;

　public　void　run()
　{
　　while　(!exit);
　}
　public　static　void　main(String[]　args)　throws　Exception
　{
　　ThreadFlag　thread　=　new　ThreadFlag();
　　thread.start();
　　sleep(5000);　//　主线程延迟5秒
　　thread.exit　=　true;　　//　终止线程thread
　　thread.join();
　　System.out.println("线程退出!");
　}
}

在上面代码中界说了一个退出符号exit，当exit为true时，while轮回退出，exit的默认值为false。在界说exit时，利用了一个Java要害字volatile，这个要害字的目标是使exit同步，也就是说在同一时刻只能由一个线程来修改exit的值，

2.利用stop要领终止线程

利用stop要领可以强行终止正在运行或挂起的线程。我们可以利用如下的代码来终止线程：

thread.stop();

固然利用上面的代码可以终止线程，但利用stop要领是很危险的，就象溘然封锁计较机电源，而不是按正常措施关机一样，大概会发生不行预料的功效，因此，并不推荐利用stop要领来终止线程。

#p#副标题#e#

3.利用interrupt要领终止线程

利用interrupt要领来终端线程可分为两种环境：

（1）线程处于阻塞状态，如利用了sleep要领。

（2）利用while(!isInterrupted()){…}来判定线程是否被间断。

在第一种环境下利用interrupt要领，sleep要领将抛出一个InterruptedException破例，而在第二种环境下线程将直接退出。下面的代码演示了在第一种环境下利用interrupt要领。

package　chapter2;

public　class　ThreadInterrupt　extends　Thread
{
　public　void　run()
　{
　　try
　　{
　　　sleep(50000);　　//　延迟50秒
　　}
　　catch　(InterruptedException　e)
　　{
　　　System.out.println(e.getMessage());
　　}
　}
　public　static　void　main(String[]　args)　throws　Exception
　{
　　Thread　thread　=　new　ThreadInterrupt();
　　thread.start();
　　System.out.println("在50秒之内按任意键间断线程!");
　　System.in.read();
　　thread.interrupt();
　　thread.join();
　　System.out.println("线程已经退出!");
　}
}

上面代码的运行功效如下：

在50秒之内按任意键间断线程!

sleep　interrupted
线程已经退出!

在挪用interrupt要领后， sleep要领抛出异常，然后输堕落误信息：sleep interrupted。

#p#分页标题#e#

留意：在Thread类中有两个要领可以判定线程是否通过interrupt要领被终止。一个是静态的要领interrupted()，一个长短静态的要领isInterrupted()，这两个要领的区别是interrupted用来判定当前线是否被间断，而isInterrupted可以用来判定其他线程是否被间断。因此，while (!isInterrupted())也可以换成while (!Thread.interrupted())。