詳解Java多執行緒程式設計中執行緒的啟動、中斷或終止操作
- 高洛峰原創
- 2017-01-05 15:37:101427瀏覽
線程啟動：
1.start() 和 run()的區別說明
start() : 它的作用是啟動一個新線程，新線程會執行對應的run()方法。 start()不能被重複呼叫。
run() : run()就和普通的成員方法一樣，可以重複呼叫。單獨呼叫run()的話，會在目前執行緒中執行run()，而並不會啟動新執行緒！
下面以程式碼來進行說明。
class MyThread extends Thread{
public void run(){
...
}
};
MyThread mythread = new MyThread();
mythread.start()會啟動一個新線程，並在新執行緒中執行run()方法。
而mythread.run()則會直接在目前執行緒中執行run()方法，並不會啟動一個新執行緒來執行run()。
2.start() 和 run()的區別範例
下面，透過一個簡單範例來示範它們之間的差異。原始碼如下：
// Demo.java 的源码
class MyThread extends Thread{
public MyThread(String name) {
super(name);
}
public void run(){
System.out.println(Thread.currentThread().getName()+" is running");
}
};
public class Demo {
public static void main(String[] args) {
Thread mythread=new MyThread("mythread");
System.out.println(Thread.currentThread().getName()+" call mythread.run()");
mythread.run();
System.out.println(Thread.currentThread().getName()+" call mythread.start()");
mythread.start();
}
}
運行結果：
main call mythread.run() main is running main call mythread.start() mythread is running
結果說明：
(1) Thread.current(當前執行緒是指正在cpu中調度執行的執行緒。
(2) mythread.run()是在「主執行緒main」中呼叫的，該run()方法直接運行在「主執行緒main」上。
(3) mythread.start()會啟動“線程mythread”，“線程mythread”啟動之後，會呼叫run()方法；此時的run()方法是運行在“線程mythread”上。
執行緒的中斷和終止
一、執行緒中斷：interrupt()
interrupt()的作用是中斷本執行緒。
本執行緒中斷自己是被允許的；其它執行緒呼叫本執行緒的interrupt()方法時，會透過checkAccess()檢查權限。這有可能拋出SecurityException異常。
如果本執行緒是處於阻塞狀態：呼叫執行緒的wait(), wait(long)或wait(long, int)會讓它進入等待(阻塞)狀態，或是呼叫執行緒的join(), join(long), join(long, int), sleep(long), sleep(long, int)也會讓它進入阻塞狀態。若執行緒在阻塞狀態時，呼叫了它的interrupt()方法，那麼它的「中斷狀態」會被清除並且會收到一個InterruptedException異常。例如，執行緒透過wait()進入阻塞狀態，此時透過interrupt()中斷該執行緒；呼叫interrupt()會立即將執行緒的中斷標記設為“true”，但由於執行緒處於阻塞狀態，所以該“中斷標記”會立即被清除為“false”，同時，會產生一個InterruptedException的異常。
如果執行緒被阻塞在一個Selector選擇器中，那麼透過interrupt()中斷它時；執行緒的中斷標記會被設定為true，並且它會立即從選擇操作中傳回。
如果不屬於前面所說的情況，那麼透過interrupt()中斷執行緒時，它的中斷標記會被設定為「true」。
中斷一個「已終止的執行緒」不會產生任何操作。
二、執行緒終止
Thread中的stop()和suspend()方法，由於固有的不安全性，已經建議不再使用！
下面，我先分別討論執行緒在「阻塞狀態」和「運行狀態」的終止方式，然後再總結出一個通用的方式。
1. 終止處於「阻塞狀態」的執行緒
通常，我們以「中斷」方式終止處於「阻塞狀態」的執行緒。
當執行緒因為被呼叫了sleep(), wait(), join()等方法而進入阻塞狀態；若此時呼叫執行緒的interrupt()將執行緒的中斷標記設為true。由於處於阻塞狀態，中斷標記會被清除，同時產生一個InterruptedException異常。將InterruptedException放在適當的為止就能終止線程，形式如下：
@Override
public void run() {
try {
while (true) {
// 执行任务...
}
} catch (InterruptedException ie) {
// 由于产生InterruptedException异常，退出while(true)循环，线程终止！
}
}
說明：在while(true)中不斷的執行任務，當線程處於阻塞狀態時，調用線程的interrupt()產生Interruptedion中斷。中斷的捕捉在while(true)之外，這樣就退出了while(true)循環！
注意：對InterruptedException的捕獲務一般放在while(true)循環體的外面，這樣，在產生異常時就退出了while(true)循環。否則，InterruptedException在while(true)循環體之內，就需要額外的添加退出處理。形式如下：
@Override
public void run() {
while (true) {
try {
// 执行任务...
} catch (InterruptedException ie) {
// InterruptedException在while(true)循环体内。
// 当线程产生了InterruptedException异常时，while(true)仍能继续运行！需要手动退出
break;
}
}
}
說明：上面的InterruptedException異常的捕捉在whle(true)之內。當產生InterruptedException異常時，被catch處理之外，仍然在while(true)循環體內；要退出while(true)循環體，需要額外的執行退出while(true)的操作。
2. 終止處於「運行狀態」的執行緒
通常，我們以「標記」方式終止處於「運行狀態」的執行緒。其中，包括「中斷標記」和「額外新增標記」。
(1) 透過「中斷標記」終止執行緒。
形式如下：
@Override
public void run() {
while (!isInterrupted()) {
// 执行任务...
}
}
说明：isInterrupted()是判断线程的中断标记是不是为true。当线程处于运行状态，并且我们需要终止它时；可以调用线程的interrupt()方法，使用线程的中断标记为true，即isInterrupted()会返回true。此时，就会退出while循环。
注意：interrupt()并不会终止处于“运行状态”的线程！它会将线程的中断标记设为true。
(2) 通过“额外添加标记”。
形式如下：
private volatile boolean flag= true;
protected void stopTask() {
flag = false;
}
@Override
public void run() {
while (flag) {
// 执行任务...
}
}
说明：线程中有一个flag标记，它的默认值是true；并且我们提供stopTask()来设置flag标记。当我们需要终止该线程时，调用该线程的stopTask()方法就可以让线程退出while循环。
注意：将flag定义为volatile类型，是为了保证flag的可见性。即其它线程通过stopTask()修改了flag之后，本线程能看到修改后的flag的值。
综合线程处于“阻塞状态”和“运行状态”的终止方式，比较通用的终止线程的形式如下：
@Override
public void run() {
try {
// 1. isInterrupted()保证，只要中断标记为true就终止线程。
while (!isInterrupted()) {
// 执行任务...
}
} catch (InterruptedException ie) {
// 2. InterruptedException异常保证，当InterruptedException异常产生时，线程被终止。
}
}
3. 终止线程的示例
interrupt()常常被用来终止“阻塞状态”线程。参考下面示例：
// Demo1.java的源码
class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
try {
int i=0;
while (!isInterrupted()) {
Thread.sleep(100); // 休眠100ms
i++;
System.out.println(Thread.currentThread().getName()+" ("+this.getState()+") loop " + i);
}
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() +" ("+this.getState()+") catch InterruptedException.");
}
}
}
public class Demo1 {
public static void main(String[] args) {
try {
Thread t1 = new MyThread("t1"); // 新建“线程t1”
System.out.println(t1.getName() +" ("+t1.getState()+") is new.");
t1.start(); // 启动“线程t1”
System.out.println(t1.getName() +" ("+t1.getState()+") is started.");
// 主线程休眠300ms，然后主线程给t1发“中断”指令。
Thread.sleep(300);
t1.interrupt();
System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted.");
// 主线程休眠300ms，然后查看t1的状态。
Thread.sleep(300);
System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted now.");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果：
t1 (NEW) is new. t1 (RUNNABLE) is started. t1 (RUNNABLE) loop 1 t1 (RUNNABLE) loop 2 t1 (TIMED_WAITING) is interrupted. t1 (RUNNABLE) catch InterruptedException. t1 (TERMINATED) is interrupted now.
结果说明：
(1) 主线程main中通过new MyThread("t1")创建线程t1，之后通过t1.start()启动线程t1。
(2) t1启动之后，会不断的检查它的中断标记，如果中断标记为“false”；则休眠100ms。
(3) t1休眠之后，会切换到主线程main；主线程再次运行时，会执行t1.interrupt()中断线程t1。t1收到中断指令之后，会将t1的中断标记设置“false”，而且会抛出InterruptedException异常。在t1的run()方法中，是在循环体while之外捕获的异常；因此循环被终止。
我们对上面的结果进行小小的修改，将run()方法中捕获InterruptedException异常的代码块移到while循环体内。
// Demo2.java的源码
class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
int i=0;
while (!isInterrupted()) {
try {
Thread.sleep(100); // 休眠100ms
} catch (InterruptedException ie) {
System.out.println(Thread.currentThread().getName() +" ("+this.getState()+") catch InterruptedException.");
}
i++;
System.out.println(Thread.currentThread().getName()+" ("+this.getState()+") loop " + i);
}
}
}
public class Demo2 {
public static void main(String[] args) {
try {
Thread t1 = new MyThread("t1"); // 新建“线程t1”
System.out.println(t1.getName() +" ("+t1.getState()+") is new.");
t1.start(); // 启动“线程t1”
System.out.println(t1.getName() +" ("+t1.getState()+") is started.");
// 主线程休眠300ms，然后主线程给t1发“中断”指令。
Thread.sleep(300);
t1.interrupt();
System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted.");
// 主线程休眠300ms，然后查看t1的状态。
Thread.sleep(300);
System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted now.");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果：
t1 (NEW) is new. t1 (RUNNABLE) is started. t1 (RUNNABLE) loop 1 t1 (RUNNABLE) loop 2 t1 (TIMED_WAITING) is interrupted. t1 (RUNNABLE) catch InterruptedException. t1 (RUNNABLE) loop 3 t1 (RUNNABLE) loop 4 t1 (RUNNABLE) loop 5 t1 (TIMED_WAITING) is interrupted now. t1 (RUNNABLE) loop 6 t1 (RUNNABLE) loop 7 t1 (RUNNABLE) loop 8 t1 (RUNNABLE) loop 9 ...
结果说明：
程序进入了死循环！
为什么会这样呢？这是因为，t1在“等待(阻塞)状态”时，被interrupt()中断；此时，会清除中断标记[即isInterrupted()会返回false]，而且会抛出InterruptedException异常[该异常在while循环体内被捕获]。因此，t1理所当然的会进入死循环了。
解决该问题，需要我们在捕获异常时，额外的进行退出while循环的处理。例如，在MyThread的catch(InterruptedException)中添加break 或 return就能解决该问题。
下面是通过“额外添加标记”的方式终止“状态状态”的线程的示例：
// Demo3.java的源码
class MyThread extends Thread {
private volatile boolean flag= true;
public void stopTask() {
flag = false;
}
public MyThread(String name) {
super(name);
}
@Override
public void run() {
synchronized(this) {
try {
int i=0;
while (flag) {
Thread.sleep(100); // 休眠100ms
i++;
System.out.println(Thread.currentThread().getName()+" ("+this.getState()+") loop " + i);
}
} catch (InterruptedException ie) {
System.out.println(Thread.currentThread().getName() +" ("+this.getState()+") catch InterruptedException.");
}
}
}
}
public class Demo3 {
public static void main(String[] args) {
try {
MyThread t1 = new MyThread("t1"); // 新建“线程t1”
System.out.println(t1.getName() +" ("+t1.getState()+") is new.");
t1.start(); // 启动“线程t1”
System.out.println(t1.getName() +" ("+t1.getState()+") is started.");
// 主线程休眠300ms，然后主线程给t1发“中断”指令。
Thread.sleep(300);
t1.stopTask();
System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted.");
// 主线程休眠300ms，然后查看t1的状态。
Thread.sleep(300);
System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted now.");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果：
t1 (NEW) is new. t1 (RUNNABLE) is started. t1 (RUNNABLE) loop 1 t1 (RUNNABLE) loop 2 t1 (TIMED_WAITING) is interrupted. t1 (RUNNABLE) loop 3 t1 (TERMINATED) is interrupted now.
更多详解Java多线程编程中线程的启动、中断或终止操作相关文章请关注PHP中文网！