java筆試要點（java多線程）
一.線程的生命週期及五種基本狀態html
關於Java中線程的生命週期，首先看一下下面這張較爲經典的圖：java
上圖中基本上囊括了Java中多線程各重要知識點。掌握了上圖中的各知識點，Java中的多線程也就基本上掌握了。主要包括：git
Java線程具備五中基本狀態程序員
新建狀態（New）：當線程對象對建立後，即進入了新建狀態，如：Thread t = new MyThread();github
就緒狀態（Runnable）：當調用線程對象的start()方法（t.start();），線程即進入就緒狀態。處於就緒狀態的線程，只是說明此線程已經作好了準備，隨時等待CPU調度執行，並非說執行了t.start()此線程當即就會執行；編程
運行狀態（Running）：當CPU開始調度處於就緒狀態的線程時，此時線程才得以真正執行，即進入到運行狀態。注：就 緒狀態是進入到運行狀態的惟一入口，也就是說，線程要想進入運行狀態執行，首先必須處於就緒狀態中；安全
阻塞狀態（Blocked）：處於運行狀態中的線程因爲某種緣由，暫時放棄對CPU的使用權，中止執行，此時進入阻塞狀態，直到其進入到就緒狀態，才 有機會再次被CPU調用以進入到運行狀態。根據阻塞產生的緣由不一樣，阻塞狀態又能夠分爲三種：多線程
1.等待阻塞：運行狀態中的線程執行wait()方法，使本線程進入到等待阻塞狀態；架構
2.同步阻塞 -- 線程在獲取synchronized同步鎖失敗(由於鎖被其它線程所佔用)，它會進入同步阻塞狀態；併發
3.其餘阻塞 -- 經過調用線程的sleep()或join()或發出了I/O請求時，線程會進入到阻塞狀態。當sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程從新轉入就緒狀態。
死亡狀態（Dead）：線程執行完了或者因異常退出了run()方法，該線程結束生命週期。
二. Java多線程的建立及啓動
Java中線程的建立常見有如三種基本形式
1.繼承Thread類，重寫該類的run()方法。
1 class MyThread extends Thread {
2
3 private int i = 0;
4
5 @Override
6 public void run() {
7 for (i = 0; i < 100; i++) {
8 System.out.println(Thread.currentThread().getName() + " " + i);
9 }
10 }
11 }
1 public class ThreadTest {
2
3 public static void main(String[] args) {
4 for (int i = 0; i < 100; i++) {
5 System.out.println(Thread.currentThread().getName() + " " + i);
6 if (i == 30) {
7 Thread myThread1 = new MyThread(); // 建立一個新的線程 myThread1 此線程進入新建狀態
8 Thread myThread2 = new MyThread(); // 建立一個新的線程 myThread2 此線程進入新建狀態
9 myThread1.start(); // 調用start()方法使得線程進入就緒狀態
10 myThread2.start(); // 調用start()方法使得線程進入就緒狀態
11 }
12 }
13 }
14 }
如上所示，繼承Thread類，經過重寫run()方法定義了一個新的線程類MyThread，其中run()方法的方法體表明瞭線程須要完成的任務，稱之爲線程執行體。當建立此線程類對象時一個新的線程得以建立，並進入到線程新建狀態。經過調用線程對象引用的start()方法，使得該線程進入到就緒狀態，此時此線程並不必定會立刻得以執行，這取決於CPU調度時機。
2.實現Runnable接口，並重寫該接口的run()方法，該run()方法一樣是線程執行體，建立Runnable實現類的實例，並以此實例做爲Thread類的target來建立Thread對象，該Thread對象纔是真正的線程對象。
1 class MyRunnable implements Runnable {
2 private int i = 0;
3
4 @Override
5 public void run() {
6 for (i = 0; i < 100; i++) {
7 System.out.println(Thread.currentThread().getName() + " " + i);
8 }
9 }
10 }
1 public class ThreadTest {
2
3 public static void main(String[] args) {
4 for (int i = 0; i < 100; i++) {
5 System.out.println(Thread.currentThread().getName() + " " + i);
6 if (i == 30) {
7 Runnable myRunnable = new MyRunnable(); // 建立一個Runnable實現類的對象
8 Thread thread1 = new Thread(myRunnable); // 將myRunnable做爲Thread target建立新的線程
9 Thread thread2 = new Thread(myRunnable);
10 thread1.start(); // 調用start()方法使得線程進入就緒狀態
11 thread2.start();
12 }
13 }
14 }
15 }
相信以上兩種建立新線程的方式你們都很熟悉了，那麼Thread和Runnable之間究竟是什麼關係呢？咱們首先來看一下下面這個例子。
1 public class ThreadTest {
2
3 public static void main(String[] args) {
4 for (int i = 0; i < 100; i++) {
5 System.out.println(Thread.currentThread().getName() + " " + i);
6 if (i == 30) {
7 Runnable myRunnable = new MyRunnable();
8 Thread thread = new MyThread(myRunnable);
9 thread.start();
10 }
11 }
12 }
13 }
14
15 class MyRunnable implements Runnable {
16 private int i = 0;
17
18 @Override
19 public void run() {
20 System.out.println("in MyRunnable run");
21 for (i = 0; i < 100; i++) {
22 System.out.println(Thread.currentThread().getName() + " " + i);
23 }
24 }
25 }
26
27 class MyThread extends Thread {
28
29 private int i = 0;
30
31 public MyThread(Runnable runnable){
32 super(runnable);
33 }
34
35 @Override
36 public void run() {
37 System.out.println("in MyThread run");
38 for (i = 0; i < 100; i++) {
39 System.out.println(Thread.currentThread().getName() + " " + i);
40 }
41 }
42 }
一樣的，與實現Runnable接口建立線程方式類似，不一樣的地方在於
1 Thread thread = new MyThread(myRunnable);
那麼這種方式能夠順利建立出一個新的線程麼？答案是確定的。至於此時的線程執行體究竟是MyRunnable接口中的run()方法仍是MyThread類中的run()方法呢？經過輸出咱們知道線程執行體是MyThread類中的run()方法。其實緣由很簡單，由於Thread類自己也是實現了Runnable接口，而run()方法最早是在Runnable接口中定義的方法。
1 public interface Runnable {
2
3 public abstract void run();
4
5 }
咱們看一下Thread類中對Runnable接口中run()方法的實現：
@Override
public void run() {
if (target != null) {
target.run();
}
}
也就是說，當執行到Thread類中的run()方法時，會首先判斷target是否存在，存在則執行target中的run()方法，也就是實現了Runnable接口並重寫了run()方法的類中的run()方法。可是上述給到的列子中，因爲多態的存在，根本就沒有執行到Thread類中的run()方法，而是直接先執行了運行時類型即MyThread類中的run()方法。（做者這些提到的多態，實際上是指這裏調用的是MyThread類的run方法，並無調用super.run()）
3.使用Callable和Future接口建立線程。具體是建立Callable接口的實現類，並實現call()方法。並使用FutureTask類來包裝Callable實現類的對象，且以此FutureTask對象做爲Thread對象的target來建立線程。
看着好像有點複雜，直接來看一個例子就清晰了。
1 public class ThreadTest {
2
3 public static void main(String[] args) {
4
5 Callable<Integer> myCallable = new MyCallable(); // 建立MyCallable對象
6 FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask來包裝MyCallable對象
7
8 for (int i = 0; i < 100; i++) {
9 System.out.println(Thread.currentThread().getName() + " " + i);
10 if (i == 30) {
11 Thread thread = new Thread(ft); //FutureTask對象做爲Thread對象的target建立新的線程
12 thread.start(); //線程進入到就緒狀態
13 }
14 }
15
16 System.out.println("主線程for循環執行完畢..");
17
18 try {
19 int sum = ft.get(); //取得新建立的新線程中的call()方法返回的結果
20 System.out.println("sum = " + sum);
21 } catch (InterruptedException e) {
22 e.printStackTrace();
23 } catch (ExecutionException e) {
24 e.printStackTrace();
25 }
26
27 }
28 }
29
30
31 class MyCallable implements Callable<Integer> {
32 private int i = 0;
33
34 // 與run()方法不一樣的是，call()方法具備返回值
35 @Override
36 public Integer call() {
37 int sum = 0;
38 for (; i < 100; i++) {
39 System.out.println(Thread.currentThread().getName() + " " + i);
40 sum += i;
41 }
42 return sum;
43 }
44
45 }
首先，咱們發現，在實現Callable接口中，此時再也不是run()方法了，而是call()方法，此call()方法做爲線程執行體，同時還具備返回值！在建立新的線程時，是經過FutureTask來包裝MyCallable對象，同時做爲了Thread對象的target。那麼看下FutureTask類的定義：
1 public class FutureTask<V> implements RunnableFuture<V> {
2
3 //....
4
5 }
1 public interface RunnableFuture<V> extends Runnable, Future<V> {
2
3 void run();
4
5 }
因而，咱們發現FutureTask類其實是同時實現了Runnable和Future接口，由此才使得其具備Future和Runnable雙重特性。經過Runnable特性，能夠做爲Thread對象的target，而Future特性，使得其能夠取得新建立線程中的call()方法的返回值。
執行下此程序，咱們發現sum = 4950永遠都是最後輸出的。而「主線程for循環執行完畢..」則極可能是在子線程循環中間輸出。由CPU的線程調度機制，咱們知道，「主線程for循環執行完畢..」的輸出時機是沒有任何問題的，那麼爲何sum =4950會永遠最後輸出呢？
緣由在於經過ft.get()方法獲取子線程call()方法的返回值時，當子線程此方法還未執行完畢，ft.get()方法會一直阻塞，直到call()方法執行完畢才能取到返回值。
上述主要講解了三種常見的線程建立方式，對於線程的啓動而言，都是調用線程對象的start()方法，須要特別注意的是：不能對同一線程對象兩次調用start()方法。
三. Java多線程的就緒、運行和死亡狀態
就緒狀態轉換爲運行狀態：當此線程獲得處理器資源；
運行狀態轉換爲就緒狀態：當此線程主動調用yield()方法或在運行過程當中失去處理器資源。
運行狀態轉換爲死亡狀態：當此線程線程執行體執行完畢或發生了異常。
此處須要特別注意的是：當調用線程的yield()方法時，線程從運行狀態轉換爲就緒狀態，但接下來CPU調度就緒狀態中的哪一個線程具備必定的隨機性，所以，可能會出現A線程調用了yield()方法後，接下來CPU仍然調度了A線程的狀況。
因爲實際的業務須要，經常會遇到須要在特定時機終止某一線程的運行，使其進入到死亡狀態。目前最通用的作法是設置一boolean型的變量，當條件知足時，使線程執行體快速執行完畢。如：
1 public class ThreadTest {
2
3 public static void main(String[] args) {
4
5 MyRunnable myRunnable = new MyRunnable();
6 Thread thread = new Thread(myRunnable);
7
8 for (int i = 0; i < 100; i++) {
9 System.out.println(Thread.currentThread().getName() + " " + i);
10 if (i == 30) {
11 thread.start();
12 }
13 if(i == 40){
14 myRunnable.stopThread();
15 }
16 }
17 }
18 }
19
20 class MyRunnable implements Runnable {
21
22 private boolean stop;
23
24 @Override
25 public void run() {
26 for (int i = 0; i < 100 && !stop; i++) {
27 System.out.println(Thread.currentThread().getName() + " " + i);
28 }
29 }
30
31 public void stopThread() {
32 this.stop = true;
33 }
34
35 }
做者關於中止一個線程的描述有些模糊。
我另外找到的比較完整的解釋以下：
與此問題相關的內容主要涉及三部分：已廢棄的Thread.stop()、迷惑的thread.interrupt系列、最佳實踐Shared Variable。
已廢棄的Thread.stop()
@Deprecated
public final void stop() { stop(new ThreadDeath()); } |
如上是Hotspot JDK 7中的java.lang.Thread.stop()的代碼，學習一下它的doc：
該方法天生是不安全的。使用thread.stop()中止一個線程，致使釋放（解鎖）全部該線程已經鎖定的監視器（因沿堆棧向上傳播的未檢查異常ThreadDeath而解鎖）。若是以前受這些監視器保護的任何對象處於不一致狀態，則不一致狀態的對象（受損對象）將對其餘線程可見，這可能致使任意的行爲。
是否是差點被這段話繞暈，俗點說：目標線程可能持有一個監視器，假設這個監視器控制着某兩個值之間的邏輯關係，如var1必須小於var2，某一時刻var1等於var2，原本應該受保護的邏輯關係，不幸的是此時剛好收到一個stop命令，產生一個ThreadDeath錯誤，監視器被解鎖。這就致使邏輯錯誤，固然這種狀況也可能不會發生，是不可預料的。注意：ThreadDeath是何方神聖？是個java.lang.Error，不是java.lang.Exception。
public class ThreadDeath extends Error { private static final long serialVersionUID = -4417128565033088268L; } |
thread.stop()方法的許多應用應該由「只修改某些變量以指示目標線程應該中止」的代碼取代。目標線程應週期性的檢查該變量，當發現該變量指示其要中止運行，則退出run方法。若是目標線程等待很長時間，則應該使用interrupt方法中斷該等待。
其實這裏已經暗示中止一個線程的最佳方法：條件變量 或 條件變量+中斷。
其它關於stop方法的doc：
- 該方法強迫中止一個線程，並拋出一個新建立的ThreadDeath對象做爲異常。
- 中止一個還沒有啓動的線程是容許的，若是稍後啓動該線程，它會當即終止。
- 一般不該試圖捕獲ThreadDeath，除非它必須執行某些異常的清除操做。若是catch子句捕獲了一個ThreadDeath對象，則必須從新拋出該對象，這樣該線程纔會真正終止。
小結：
Thread.stop()不安全，已再也不建議使用。
使人迷惑的thread.interrupt()
Thread類中有三個方法會令新手迷惑，他們是：
public void Thread.interrupt() // 無返回值 public boolean Thread.isInterrupted() // 有返回值 public static boolean Thread.interrupted() // 靜態，有返回值 |
若是按照近幾年流行的重構，代碼整潔之道，程序員修煉之道等書的觀點，這幾個方法的命名相對於其實現的功能來講，不夠直觀明確，極易使人混淆，是低級程序猿的代碼。逐個分析：
public void interrupt() { if (this != Thread.currentThread()) checkAccess(); synchronized (blockerLock) { Interruptible b = blocker; if (b != null) { interrupt0(); // Just to set the interrupt flag b.interrupt(this); return; } } interrupt0(); } |
中斷本線程。無返回值。具體做用分如下幾種狀況：
- 若是該線程正阻塞於Object類的wait()、wait(long)、wait(long, int)方法，或者Thread類的join()、join(long)、join(long, int)、sleep(long)、sleep(long, int)方法，則該線程的中斷狀態將被清除，並收到一個java.lang.InterruptedException。
- 若是該線程正阻塞於interruptible channel上的I/O操做，則該通道將被關閉，同時該線程的中斷狀態被設置，並收到一個java.nio.channels.ClosedByInterruptException。
- 若是該線程正阻塞於一個java.nio.channels.Selector操做，則該線程的中斷狀態被設置，它將當即從選擇操做返回，並可能帶有一個非零值，就好像調用java.nio.channels.Selector.wakeup()方法同樣。
- 若是上述條件都不成立，則該線程的中斷狀態將被設置。
小結：第一種狀況最爲特殊，阻塞於wait/join/sleep的線程，中斷狀態會被清除掉，同時收到著名的InterruptedException；而其餘狀況中斷狀態都被設置，並不必定收到異常。
中斷一個不處於活動狀態的線程不會有任何做用。若是是其餘線程在中斷該線程，則java.lang.Thread.checkAccess()方法就會被調用，這可能拋出java.lang.SecurityException。
public static boolean interrupted() { return currentThread().isInterrupted(true); } |
檢測當前線程是否已經中斷，是則返回true，不然false，並清除中斷狀態。換言之，若是該方法被連續調用兩次，第二次必將返回false，除非在第一次與第二次的瞬間線程再次被中斷。若是中斷調用時線程已經不處於活動狀態，則返回false。
public boolean isInterrupted() { return isInterrupted(false); } |
檢測當前線程是否已經中斷，是則返回true，不然false。中斷狀態不受該方法的影響。若是中斷調用時線程已經不處於活動狀態，則返回false。
interrupted()與isInterrupted()的惟一區別是，前者會讀取並清除中斷狀態，後者僅讀取狀態。
在hotspot源碼中，二者均經過調用的native方法isInterrupted(boolean)來實現，區別是參數值ClearInterrupted不一樣。
private native boolean isInterrupted(boolean ClearInterrupted); |
通過上面的分析，三者之間的區別已經很明確，來看一個具體案例，是我在工做中看到某位架構師的代碼，只給出最簡單的概要結構：
public void run() { while(!Thread.currentThread().isInterrupted()) { try { Thread.sleep(10000L); ... //爲篇幅，省略其它io操做 ... //爲簡單，省略其它interrupt操做 } catch (InterruptedException e) { break; } } } |
我最初被這段代碼直接繞暈，用thread.isInterrupted()方法做爲循環停止條件能夠嗎？
根據上文的分析，當該方法阻塞於wait/join/sleep時，中斷狀態會被清除掉，同時收到InterruptedException，也就是接收到的值爲false。上述代碼中，當sleep以後的調用otherDomain.xxx()，otherDomain中的代碼包含wait/join/sleep而且InterruptedException被catch掉的時候，線程沒法正確的中斷。
所以，在編寫多線程代碼的時候，任什麼時候候捕獲到InterruptedException，要麼繼續上拋，要麼重置中斷狀態，這是最安全的作法，參考『Java Concurrency in Practice』。凡事沒有絕對，若是你能夠確保必定沒有這種狀況發生，這個代碼也是能夠的。
下段內容引自：『Java併發編程實戰』 第5章 基礎構建模塊 5.4 阻塞方法與中斷方法 p77
當某個方法拋出InterruptedException時，表示該方法是一個阻塞方法。當在代碼中調用一個將拋出InterruptedException異常的方法時，你本身的方法也就變成了一個阻塞方法，而且必需要處理對中斷的相應。對於庫代碼來講，有兩種選擇：
- 傳遞InterruptedException。這是最明智的策略，將異常傳遞給方法的調用者。
- 恢復中斷。在不能上拋的狀況下，如Runnable方法，必須捕獲InterruptedException，並經過當前線程的interrupt()方法恢復中斷狀態，這樣在調用棧中更高層的代碼將看到引起了一箇中斷。以下代碼是模板：
public void run() { try { // ① 調用阻塞方法 } catch (InterruptedException e) { Thread.currentThread().interrupt(); // ② 恢復被中斷的狀態 } } |
最後再強調一遍，②處的 Thread.currentThread().interrupt() 很是很是重要。
最佳實踐：Shared Variable
不記得哪本書上曾曰過，最佳實踐是個爛詞。在這裏這個詞最能表達意思，中止一個線程最好的作法就是利用共享的條件變量。
對於本問題，我認爲準確的說法是：中止一個線程的最佳方法是讓它執行完畢，沒有辦法當即中止一個線程，但你能夠控制什麼時候或什麼條件下讓他執行完畢。
經過條件變量控制線程的執行，線程內部檢查變量狀態，外部改變變量值可控制中止執行。爲保證線程間的即時通訊，須要使用使用volatile關鍵字或鎖，確保讀線程與寫線程間變量狀態一致。下面給一個最佳模板：
/** * @author bruce_sha (bruce-sha.github.io) * @version 2013-12-23 */ public class BestPractice extends Thread { private volatile boolean finished = false; // ① volatile條件變量 public void stopMe() { finished = true; // ② 發出中止信號 } @Override public void run() { while (!finished) { // ③ 檢測條件變量 // do dirty work // ④業務代碼 } } } |
當④處的代碼阻塞於wait()或sleep()時，線程不能馬上檢測到條件變量。所以②處的代碼最好同時調用interrupt()方法。
小結：
How to Stop a Thread or a Task ? 詳細討論瞭如何中止一個線程, 總結起來有三點：
- 使用violate boolean變量來標識線程是否中止。
- 中止線程時，須要調用中止線程的interrupt()方法，由於線程有可能在wait()或sleep(), 提升中止線程的即時性。
- 對於blocking IO的處理，儘可能使用InterruptibleChannel來代替blocking IO。
總結：
要使任務和線程能安全、快速、可靠地中止下來，並非一件容易的事。Java沒有提供任何機制來安全地終止線程。但它提供了中斷（Interruption），這是一種協做機制，可以使一個線程終止另外一個線程的的工做。—— 『Java併發編程實戰』 第7章 取消與關閉 p111
中斷是一種協做機制。一個線程不能強制其它線程中止正在執行的操做而去執行其它的操做。當線程A中斷B時，A僅僅是要求B在執行到某個能夠暫停的地方中止正在執行的操做——前提是若是線程B願意停下來。—— 『Java併發編程實戰』 第5章 基礎構建模塊 p77
總之，中斷只是一種協做機制，須要被中斷的線程本身處理中斷。中止一個線程最佳實踐是中斷 + 條件變量。
- 1. JAVA多線程筆試題
- 2. Java多線程編程要點 (二)
- 3. Java多線程編程要點
- 4. Java多線程編程要點 (一)
- 5. java多線程知識要點
- 6. java線程池知識要點筆記
- 7. java（集合、線程）面試要點2
- 8. java筆試要點（java.sql包）
- 9. Java多線程知識點筆記（1）
- 10. Java 多線程測試 筆記(一)
- 更多相關文章...
- • C# 多線程 - C#教程
- • SQLite - Java - SQLite教程
- • Java 8 Stream 教程
- • Tomcat學習筆記（史上最全tomcat學習筆記）
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. No provider available from registry 127.0.0.1:2181 for service com.ddbuy.ser 解決方法
- 2. Qt5.7以上調用虛擬鍵盤(支持中文)，以及源碼修改(可拖動，水平縮放)
- 3. 軟件測試面試- 購物車功能測試用例設計
- 4. ElasticSearch（概念篇）：你知道的, 爲了搜索…
- 5. redux理解
- 6. gitee創建第一個項目
- 7. 支持向量機之硬間隔（一步步推導，通俗易懂）
- 8. Mysql 異步複製延遲的原因及解決方案
- 9. 如何在運行SEPM配置嚮導時將不可認的複雜數據庫密碼改爲簡單密碼
- 10. windows系統下tftp服務器使用
- 1. JAVA多線程筆試題
- 2. Java多線程編程要點 (二)
- 3. Java多線程編程要點
- 4. Java多線程編程要點 (一)
- 5. java多線程知識要點
- 6. java線程池知識要點筆記
- 7. java（集合、線程）面試要點2
- 8. java筆試要點（java.sql包）
- 9. Java多線程知識點筆記（1）
- 10. Java 多線程測試 筆記(一)