面試系列<3>——java併發

胖墩哥發表於2021-04-22
面試Java

面試系列——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

相關文章