面試系列——java併發
一、使用執行緒
有三種使用執行緒的方法：
- 實現Runnable介面
- 實現Callable介面
- 繼承Thread類
實現 Runnable 和 Callable 介面的類只能當做一個可以線上程中執行的任務，不是真正意義上的執行緒，因此最後還需要通過 Thread 來呼叫。可以理解為任務是通過執行緒驅動從而執行的。
實現Runnable介面
public class MyRunnable implements Runnable {
@Override
public void run() {
// ...
}
}
使用Runnable例項再建立一個Thread例項，然後呼叫Thread例項的start方法來啟動執行緒。
public static void main(String[] args) {
MyRunnable instance = new MyRunnable();
Thread thread = new Thread(instance);
thread.start();
}
實現Callable介面
與Runnable相比，Callable可以有返回值，返回值通過FutureTask進行封裝
public class MyCallable implements Callable<Integer> {
public Integer call() {
return 123;
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyCallable mc = new MyCallable();
FutureTask<Integer> ft = new FutureTask<>(mc);
Thread thread = new Thread(ft);
thread.start();
System.out.println(ft.get());
}
繼承 Thread 類
同樣是需要實現run()方法，因為Thread類也實現了Runable介面。
當呼叫start（）方法啟動一個執行緒時，虛擬機器會將該執行緒放入就緒佇列中等待被排程，當一個執行緒被排程時會執行該執行緒的run方法。
public class MyThread extends Thread {
public void run() {
// ...
}
}
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.start();
}
實現介面VS繼承Thread
實現介面會更好一些，因為：
- java不支援多重繼承，因此繼承了Thread類就無法繼承其他類，但是可以實現多個介面
- 類可能只要求可執行就行，繼承整個Thread類開銷過大。
二、基礎執行緒機制
執行緒池有什麼作用？
執行緒池作用就是限制系統中執行執行緒的數量。
1、提高效率 建立好一定數量的執行緒放在池中，等需要使用的時候就從池中拿一個，這要比需要的時候建立一個執行緒物件要快的多。
2、方便管理 可以編寫執行緒池管理程式碼對池中的執行緒統一進行管理，比如說啟動時有該程式建立100個執行緒，每當有請求的時候，就分配一個執行緒去工作，如果剛好併發有101個請求，那多出的這一個請求可以排隊等候，避免因無休止的建立執行緒導致系統崩潰。
Executor
Executor管理多個非同步任務的執行，而無需程式設計師顯式地管理執行緒的生命週期。這裡的非同步是指多個任務的執行互不干擾，不需要進行同步操作。
主要有三種Executor：
- CachedThreadPool：一個任務建立一個執行緒，無限擴大，適合輕負載。
- FixedThreadPool：所有任務只能使用固定大小的執行緒，固定執行緒池，適合重負載。
- SingleThreadExecutor：相當於大小為1的FixedThreadPool.建立單執行緒的執行緒池，適用於需要保證順序執行各個任務。
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++) {
executorService.execute(new MyRunnable());
}
executorService.shutdown();
}
Daemon
守護執行緒是程式執行時在後臺提供服務的執行緒，不屬於程式中不可或缺的部分。
當所有非守護執行緒結束時，程式也就終止，同時會殺死所有守護執行緒。
mian()屬於非守護執行緒。
線上程啟動之前使用setDaemon()方法可以將一個執行緒設定為守護執行緒。
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable());
thread.setDaemon(true);
}
sleep()
Thread.sleep（millisec）方法會休眠當前正在執行的執行緒，millisec單位為毫秒。
sleep()可能會丟擲InterruptedExecption，因為異常不能跨執行緒傳播回main()中，因此必須在本地處理。執行緒中丟擲的其他異常也同樣需要在本地進行處理。
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
三、中斷
一個執行緒執行完畢之後會自動結束，如果在執行過程中發生異常也會提前結束。
InterruptedExecption
通過呼叫一個執行緒的interrupt()來中斷該執行緒，如果該執行緒處於阻塞、限期等待或者無限期等待狀態，那麼就會丟擲InterruptedException，從而提前結束該執行緒。但是不能中斷I/O阻塞和suynchronized鎖阻塞。
對於以下程式碼,在main()中啟動一個執行緒之後再中斷它，由於執行緒中呼叫了Thread.sleep()方法， 因此會丟擲一個 InterruptedException，從而提前結束執行緒，不執行之後的語句。
public class InterruptExample {
private static class MyThread1 extends Thread {
@Override
public void run() {
try {
Thread.sleep(2000);
System.out.println("Thread run");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new MyThread1();
thread1.start();
thread1.interrupt();
System.out.println("Main run");
}
Main run
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at InterruptExample.lambda$main$0(InterruptExample.java:5)
at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
at java.lang.Thread.run(Thread.java:745)
Executor 的中斷操作
呼叫Executor的shutdown（）方法會等待執行緒都執行完畢之後再關閉，但是如果呼叫的是shutdownNow()方法，則相當於呼叫每個執行緒的interrupt()方法。
以下使用Lambda建立執行緒，相當於建立了一個匿名內部執行緒。
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> {
try {
Thread.sleep(2000);
System.out.println("Thread run");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
executorService.shutdownNow();
System.out.println("Main run");
}
Main run
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
at java.lang.Thread.run(Thread.java:745)
如果只想中斷 Executor 中的一個執行緒，可以通過使用 submit() 方法來提交一個執行緒，它會返回一個 Future<?> 物件，通過呼叫該物件的 cancel(true) 方法就可以中斷執行緒。
Future<?> future = executorService.submit(() -> {
// ..
});
future.cancel(true);
四、互斥同步
java提供了兩種鎖機制來控制多個執行緒對共享資源的互斥訪問，第一個是JVM實現的synchronized，而另一個是JDK實現的ReentrantLock。
synchronized
1、同步一個程式碼塊
public void func() {
synchronized (this) {
// ...
}
}
它只作用於同一個物件，如果呼叫兩個物件上的同步程式碼塊，就不會進行同步。
對於以下程式碼，使用 ExecutorService 執行了兩個執行緒，由於呼叫的是同一個物件的同步程式碼塊，因此這兩個執行緒會進行同步，當一個執行緒進入同步語句塊時，另一個執行緒就必須等待。
public class SynchronizedExample {
public void func1() {
synchronized (this) {
for (int i = 0; i < 10; i++) {
System.out.print(i + " ");
}
}
}
}
public static void main(String[] args) {
SynchronizedExample e1 = new SynchronizedExample();
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> e1.func1());
executorService.execute(() -> e1.func1());
}
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
對於一下程式碼，兩個執行緒呼叫了不同物件的同步程式碼塊，因此這兩個執行緒就不需要同步。從輸出結果看出，兩個執行緒交叉執行。
public static void main(String[] args) {
SynchronizedExample e1 = new SynchronizedExample();
SynchronizedExample e2 = new SynchronizedExample();
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> e1.func1());
executorService.execute(() -> e2.func1());
}
0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
2、同步一個方法
public synchronized void func () {
// ...
}
它和同步程式碼塊一樣，作用於同一個物件
3、同步一個類
public void func() {
synchronized (SynchronizedExample.class) {
// ...
}
}
作用於整個類，也就是說兩個執行緒呼叫同一個類的不同物件上的這種同步語句，也會進行同步。
public class SynchronizedExample {
public void func2() {
synchronized (SynchronizedExample.class) {
for (int i = 0; i < 10; i++) {
System.out.print(i + " ");
}
}
}
}
public static void main(String[] args) {
SynchronizedExample e1 = new SynchronizedExample();
SynchronizedExample e2 = new SynchronizedExample();
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> e1.func2());
executorService.execute(() -> e2.func2());
}
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
4、同步一個靜態方法
public synchronized static void fun() {
// ...
}
作用於整個類。
ReentrantLock
ReentrantLock是java.util.concurrent(J.U.C)包中的鎖。
public class LockExample {
private Lock lock = new ReentrantLock();
public void func() {
lock.lock();
try {
for (int i = 0; i < 10; i++) {
System.out.print(i + " ");
}
} finally {
lock.unlock(); // 確保釋放鎖，從而避免發生死鎖。
}
}
}
public static void main(String[] args) {
LockExample lockExample = new LockExample();
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> lockExample.func());
executorService.execute(() -> lockExample.func());
}
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
比較
1、鎖的實現
synchronized是JVM實現的，而ReentrantLock是JDK實現的。
2、效能
新版本java對synchronized進行了很多優化，例如自旋鎖等，synchronized與ReentrantLock大致相同。
3、等待可中斷
當持有鎖的執行緒長期不釋放鎖的時候，正在等待的執行緒可以選擇放棄等待，改為處理其他事情。
ReentrantLock 可中斷，而 synchronized 不行。
4、公平鎖
公平鎖是指多個執行緒在等待同一個鎖時，必須按照申請鎖的時間順序來依次獲得鎖。
synchronized 中的鎖是非公平的，ReentrantLock 預設情況下也是非公平的，但是也可以是公平的。
5、鎖繫結多個條件
一個 ReentrantLock 可以同時繫結多個 Condition 物件。
使用選擇
除非使用ReentrantLock的高階功能，否則優先使用synchronized。這是因為synchronized是JVM實現的一種鎖機制，JVM原生地支援，而ReentrantLock不是所有的JDK版本都支援。並且使用synchronized不用擔心沒有釋放鎖而導致死鎖問題，因為JVM會確保鎖的釋放。
五、執行緒協作
https://www.cnblogs.com/jimlau/p/12463663.html
六、執行緒狀態
https://www.cnblogs.com/jimlau/p/12463663.html