1. Java執行緒理解
行程：行程就相當于一個應用程式，而執行緒是行程中的執行場景或者說執行單元，一個行程可以啟動多個執行緒，
執行緒并發：對于電腦的CPU，例如4核的CPU，表示在同一個時間點上，可以真正做到有4個行程并發執行，而對于單核CPU，是不能做到真正的多執行緒并發的，只是由于CPU在執行緒之間切換太快，讓我們人在使用時產生了多個執行緒在同時運行的假象，在主觀感覺上多個執行緒是并發的，但其實單核的CPU是不能做到真正的并發的，
JVM行程：運行Java程式，首先會先啟動一個JVM，JVM就是一個行程，然后JVM再啟動一個主執行緒呼叫main方法，與此同時，再啟動一個垃圾回收執行緒負責看護main主執行緒并回收其產生的垃圾，所以，一個Java程式中至少會有兩個執行緒并發，一個是垃圾回收執行緒，一個是執行main方法的主執行緒，
執行緒的記憶體使用：Java中堆記憶體和方法區記憶體在執行緒間是共享的，也就是它們在程式運行期間都只有“一塊”，但是堆疊是獨立的，每一個執行緒擁有一個自己的堆疊，啟動了多少執行緒就會有多少塊堆疊記憶體，
2. 創建執行緒的三種方式：Thread，Runnable，Callable
Thread方式：定義一個類，繼承java.lang.Thread，并重寫run方法即可，運行時，呼叫執行緒物件的start方法，然后JVM就會自動創建一個分支執行緒（分支堆疊）來運行run方法中的代碼，這種方式也是最核心的，其他兩種方式都是基于這個Thread來實作的，
Thread中的常用方法：
- void start()：start()方法的作用是啟動一個分支執行緒，呼叫時會在JVM中開辟出一個新的堆疊空間，這個堆疊空間開辟出來后start()方法就結束了，表示執行緒啟動成功了，注意，start()方法本身并不屬于新的分支執行緒，而是屬于呼叫者執行緒，start()方法結束后，啟動成功的執行緒會自動呼叫run方法，并且run方法處于分支堆疊的底部（壓堆疊），其作用和意義就相當于是分支堆疊的main方法，即主執行緒的main方法和分支執行緒的run方法對于各自的執行緒來講是意義一樣的，
- void run()：如果在當前執行緒中直接呼叫run方法，那它就是執行緒物件中的一個普通方法，并不會啟動一個新的分支執行緒，所以想要啟動一個新的分支執行緒，必須要通過呼叫start方法來運行run方法中的代碼，
- String getName()：獲取執行緒的名稱，默認為“Thread-[n]”，n表示數字，
- void setName(String name)：設定執行緒的名稱，
- static Thread currentThread()：獲取當前執行緒的執行緒物件，當前執行緒指的是正在執行currentThread()這個方法的執行緒，（注意這是個靜態方法）
- static void sleep(long millis)：使當前執行緒暫停執行指定毫秒數，（注意這是個靜態方法）
- void interrupt()：中斷sleep的睡眠，原理是呼叫sleep方法進行睡眠時，會產生一個InterruptedException的編譯時例外，代碼中通常會使用try塊將sleep方法包裹起來，當呼叫interrupt方法時，就會主動拋出一個InterruptedException例外，此時的sleep睡眠就被中斷了，
- static void yield()：執行緒讓位，讓當前執行緒短暫的暫停一下，以便讓其他執行緒得以有更多時間執行，（注意這是個靜態方法）
- void join()：執行緒合并，讓當前執行緒阻塞，直到呼叫join方法的執行緒執行完畢，即讓其他執行緒合入當前執行緒，
- void setDaemon(boolean on)：將on設定true傳入，表示在執行緒呼叫start之前將其設定為守護執行緒，注意，這個方法需要在執行緒啟動之前呼叫進行設定，Java中執行緒分為兩類，用戶執行緒和守護執行緒，守護執行緒也稱為后臺執行緒，而且守護執行緒通常是一個死回圈程式，并且所有的用戶執行緒結束之后，守護執行緒就會自動結束，不用程式員手動去結束，主執行緒main執行緒是屬于用戶執行緒，而垃圾回識訓制的執行緒則屬于守護執行緒，
Thread簡單示例：
public class ThreadTest{ public static void main(String[] args){ // main方法中的代碼屬于主執行緒，在主堆疊中運行 MyThread myThread = new MyThread(); // 呼叫執行緒物件的start方法會啟動一個新的分支執行緒，并執行執行緒物件中run方法的代碼 // 此時主執行緒的main方法并不會等myThread的run方法運行完畢，而是會直接往下繼續執行 // 因為它們屬于兩個獨立的執行緒，它們的運行是并行執行的 myThread.start(); System.out.println("主執行緒正在運行..."); } } class MyThread extends Thread { public void run(){ // run方法中的代碼會運行在創建的分支執行緒中 System.out.println("分支執行緒正在執行..."); } }
Runnable方式：定義一個類，實作java.lang.Runnable介面，并重寫介面的run方法，這個類也稱之為可運行的類，然后再創建一個Thread物件，在創建Thread物件時，構造方法中將這個自定義的可運行類物件傳入即可，
注：這種實作介面的方式其實更加常用，因為定義的可運行類在將來還可以繼承別的類，但定義Thread子類的方式因為Java只支持單繼承的原因就沒有機會再繼承別的類了，即無法通過繼承的方式擴展功能了，
Runnable簡單示例：
public class ThreadTest{ public static void main(String[] args) { MyRunnable myRunnable = new MyRunnable(); Thread t = new Thread(myRunnable); // 啟動分支執行緒，并在分支執行緒中運行myRunnable物件中的run方法 t.start(); System.out.println("主執行緒正在運行..."); } } // 這只是一個實作了Runnable介面的普通類 // 只有將它傳入Thread物件才能在單獨的執行緒中運行 class MyRunnable implements Runnable{ public void run(){ System.out.println("分支執行緒正在執行..."); } }
Callable方式：實作java.util.concurrent.Callable介面，并重寫call()方法，具體使用方法見示例，這種方式的特點是可以獲取執行緒的回傳值，但是，也有一個缺點，呼叫get方法獲取回傳值時會阻塞當前執行緒，
Callable簡單示例：
import java.util.concurrent.Callable; import java.util.concurrent.FutureTask; public class CallableTest { public static void main(String[] args) throws Exception{ // FutureTask使用了泛型，使用時可以傳入自己需要的型別 // 這里采用了匿名內部類的實作方式 FutureTask task = new FutureTask(new Callable(){ // 需要重寫call方法，就相當于Thread中的run方法 @Override public Object call() throws Exception { System.out.println("Callable執行緒正在運行..."); return new Object(); } }); Thread t = new Thread(task); t.start(); // 執行get方法是會阻塞當前執行緒（這里是主執行緒main）， // 直到執行緒t執行完畢 Object obj = task.get(); System.out.println("執行緒執行的結果：" + obj); } }
3. 使用布爾標記終止執行緒
終止執行緒的方法具體的使用場景可能有所不同，以下示例只是常用方法之一，
// 終止執行緒的一種方式：定義一個布爾標記 public class ThreadTest{ public static void main(String[] args) { MyRunnable myRunnable = new MyRunnable(); Thread t = new Thread(myRunnable); t.start(); // 主執行緒暫停5秒 try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } // 主執行緒暫停5秒之后，手動去終止t執行緒 myRunnable.run = false; } } class MyRunnable implements Runnable{ // 定義一個布爾標記 boolean run = true; public void run(){ // 讓當前執行緒sleep 10秒，模擬程式執行10秒 for (int i = 0; i < 10; i++) { if (run) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } else { // 終止執行緒 return; } } } }
4. 執行緒生命周期
執行緒生命周期的狀態通常有以下幾個狀態：新建狀態、就緒狀態、運行狀態、阻塞狀態和死亡狀態，
新建狀態：創建執行緒物件之后，呼叫start()方法之前，執行緒就處于新建狀態，此時執行緒還沒有被創建，因為一旦創建執行緒成功之后就會立馬進入就緒狀態，
就緒狀態：呼叫start()方法啟動執行緒之后，執行緒就處于就緒狀態，就緒狀態表示此時的執行緒擁有搶奪CPU的時間片的權利（CPU執行權），即我這個執行緒可以占用多少時間的CPU，當搶到時間片之后就會進入運行狀態，
運行狀態：當執行緒搶到時間片之后就會去占用CPU，并使用CPU執行run()方法中的代碼，一直到這個時間片使用完畢，時間片使用完畢之后，run方法中的代碼會暫停執行并進入就緒狀態，等下一次再次搶到時間片的時候就會繼續運行run方法中的代碼了，當在使用時間片的程序中，程式阻塞了，例如需要等待用戶輸入、程式sleep等，就會立馬釋放掉擁有的時間片，并進入阻塞狀態，
阻塞狀態：當進入阻塞狀態后，直到用戶輸入完畢、sleep時間到等，此時會解除程式的阻塞狀態，并使程式進入就緒狀態，繼續參與CPU執行權的搶奪以便運行后續的代碼，
死亡狀態：當run方法中的代碼執行完畢之后，執行緒就進入死亡狀態了，
注：對于單核CPU來說，主執行緒和分支執行緒并發時，它們都在搶奪CPU的時間片，由于它們的運行狀態交替太快，導致了我們主觀感覺上的并行，但其實并沒有真正的并發執行，
5. synchronized關鍵字
可以使用synchronized語法來實作執行緒之間的同步，以給某個代碼塊、方法或者類添加鎖的方式，以達到資料安全的目的，
代碼塊中的synchronized：在代碼塊中使用synchronized，語法如下：
/* 例如執行緒t1、t2、t3之間共享物件testShare，而需要同步的代碼正好是testShare中的一個方法， 那么synchronized就需要用在testShare中， 小括號中的"執行緒之間共享的物件"就可以寫this，而方法體中的代碼就可以放在synchronized 的大括號中來執行，這樣，同一個類new出來的不同物件就可以實作各自的執行緒間同步，互不干擾， 注意：執行緒之間共享需要共享的物件可能是不同的，而大括號中的代碼和共享物件之間不一定是有關系的， 這兩個部分可以是沒有關系的，所以這里不一定是this，這個共享物件只是給執行緒獲取鎖提供了一個物件， 多個執行緒之間只有需要獲取相同物件的鎖的時候，才會發生執行緒的同步， */ synchronized(執行緒之間共享的物件){ 需要同步的代碼 }
synchronized原理：synchronized語法實作執行緒之間同步的原理其實就是執行緒對物件鎖的占有和釋放，每一個Java物件都有一個鎖（其實就是一個標記，我們稱之為鎖而已），當第一個執行緒遇到synchronized之后就會占有小括號中“共享物件”的鎖，然后執行大括號中需要同步的代碼塊，如果在執行程序中，第二個執行緒也來到了這里，遇到了synchronized，也會去占有這個“共享物件”的鎖，但是發現它已經被占有了，那么就只好排隊等待，直到第一個執行緒執行完畢，釋放這個“共享物件”的鎖，然后第二個執行緒才能占有鎖并繼續執行后面的代碼，以此類推，后面的執行緒也會來占有鎖，如果鎖已經被占有了，就停止執行并等待，直到“有鎖可占”，如此，也就達到了這段代碼的執行緒間同步，
synchronized效率提升：
- 大括號中的內容越多，范圍越大，執行效率越低，所以應該盡量保證大括號中的內容少一點，范圍小一點，
- 對于區域變數，因為它始終都在堆疊中，而各自的執行緒都有自己的堆疊，所以區域變數是不存在執行緒安全問題的，因此，對于Java中的某些參考資料型別，在區域變數的使用中，應該使用非執行緒安全的資料型別，比如ArrayList、HashSet、StringBuilder等，它們雖然本身不是執行緒安全的，但是因為是區域變數，所以不存在執行緒安全問題，也就不用去考慮它們本身的執行緒安全問題了，
方法定義中的synchronized：synchronized可以在方法定義上使用，此時共享物件默認為this，同步的代碼為整個方法體的代碼，但是注意，如果是靜態方法，那么執行這個方法時查找的鎖就是類鎖了，而不是物件鎖了，這種用法雖然直接使用了this和整個方法體中的代碼，但是也可以看情況使用，滿足這個使用條件的就可以使用這個方式，代碼也會更簡潔，
public synchronized void myFunc(){ .... }
類定義中的synchronized：如果synchronized關鍵字出現在類的定義修飾符中，那么表示這個類創建的所有物件都擁有同一個鎖，也稱之為類鎖，類鎖的定義主要是為了保證靜態變數的執行緒安全，
6. 死鎖
當執行緒之間某個執行緒想要獲取的鎖被對方執行緒占有了，與此同時，對方執行緒想要獲取的鎖也被自己獲取了，此時兩個執行緒就都會處于一直等待的狀態，而不往下執行的情況，這種場景稱之為死鎖，
注：synchronized在開發中應該盡量避免嵌套使用，因為嵌套synchronized有可能會造成死鎖問題，而死鎖問題大多時候很難定位，
死鎖示例：
public class ThreadTest{ public static void main(String[] args){ Object o1 = new Object(); Object o2 = new Object(); MyThread1 t1 = new MyThread1(o1, o2); MyThread2 t2 = new MyThread2(o1, o2); t1.start(); t2.start(); } } class MyThread1 extends Thread{ Object o1; Object o2; public MyThread1(Object o1, Object o2){ this.o1 = o1; this.o2 = o2; } public void run(){ synchronized(o1){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } // 此時想要去獲取o2的鎖，但是已經被MyThread2的執行緒獲取了，只能暫定并等待 synchronized(o2){ System.out.println("MyThread1 run..."); } } } } class MyThread2 extends Thread{ Object o1; Object o2; public MyThread2(Object o1, Object o2){ this.o1 = o1; this.o2 = o2; } public void run(){ synchronized(o2){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } // 此時想要去獲取o1的鎖，但是已經被MyThread1的執行緒獲取了，只能暫定并等待 synchronized(o1){ System.out.println("MyThread2 run..."); } } } }
7. 定時器
使用java.util.Timer就可以自己實作一個定時器，
可以從構造方法指定定時器的名稱，以及該定時器是否作為守護執行緒運行，注意，這里說的定時器，包括了定時器本身執行緒和在定時器中運行的任務執行緒，
常用方法：
- void schedule(TimerTask task, Date firstTime, long period)：從指定的時間firstTime開始，每隔period（毫秒）時間執行一次任務task，注意，TimerTask是一個抽象類，使用時需要自己新寫一個類，繼承TimerTask并重寫它的run方法，呼叫這個方法之后，定時器就開始作業了，
8. wait和notify
wait和notify方法不是執行緒Thread類的方法，而是Object的方法，即任何類都有這兩個方法，但是注意，這兩個方法是建立在執行緒同步的機制上的，
- wait()：讓正在該物件（呼叫wait方法的物件）上活動的執行緒（當前執行緒）進入無限期等待的狀態，直到被喚醒為止，并且該執行緒會釋放在該物件上占有的鎖，
- notify()：喚醒正在該物件（呼叫notify方法的物件）上等待的執行緒，但是注意，這個方法只是起到通知的作用，并不會釋放在該物件上占有的鎖，通常是執行緒執行完畢就自動釋放了，
- notifyAll()：喚醒所有正在該物件（呼叫notify方法的物件）上等待的執行緒，這個方法同樣不會釋放物件鎖，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/159476.html
標籤：Java