解釋Java中的多執行緒機制

作者:
image

文章最後更新於 2024 年 6 月 11 日

在Java中，多執行緒機制是一種允許多個執行緒同時運行的技術。多執行緒可以提高程序的性能，尤其在處理大量獨立任務時。下面是對Java多執行緒機制的簡要解釋：

1. 創建執行緒

在Java中，可以通過兩種方式創建執行緒：

  1. 繼承Thread類：
class MyThread extends Thread {
    public void run() {
        System.out.println("My thread is running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
    }
}
  1. 實現Runnable接口：
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("My runnable is running");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t2 = new Thread(new MyRunnable());
        t2.start();
    }
}

3.使用Callable和Future：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class MyCallable implements Callable<String> {
    public String call() throws Exception {
        return "Task completed";
    }
}

public class TestCallable {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(1);
        MyCallable myCallable = new MyCallable();
        Future<String> future = executor.submit(myCallable);
        System.out.println(future.get()); // 取得返回值
        executor.shutdown();
    }
}

優點：可以返回結果或拋出異常。
缺點：需要使用ExecutorService來管理。

2. 執行緒的生命周期

執行緒有五個主要狀態：

  • 新建（New）：執行緒對象已經創建，但還沒有調用start()方法。
  • 就緒（Runnable）：調用了start()方法，等待CPU調度執行。
  • 運行（Running）：正在執行run()方法的程式碼。
  • 阻塞（Blocked）：等待某個資源或者鎖。
  • 死亡（Dead）：run()方法執行完畢，或者因為異常終止。

3. 執行緒的同步

當多個執行緒訪問共享資源時，可能會發生數據不一致的問題。為了解決這個問題，可以使用同步（synchronized）機制：

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) counter.increment();
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) counter.increment();
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + counter.getCount()); // 期望輸出為2000
    }
}

比較表

方法優點缺點適用場景
繼承Thread簡單易用無法繼承其他類單一執行緒任務
實現Runnable可以繼承其他類需要手動創建Thread對象多個執行緒任務
Callable可以返回結果或拋出異常需要使用ExecutorService任務需要返回結果或異常處理
synchronized簡單直接的同步方式可能導致性能問題（例如死鎖）簡單同步需求

4. 執行緒通信

Java提供了wait()、notify()和notifyAll()方法來實現執行緒之間的通信，這些方法必須在同步塊（synchronized block）中調用。

結語

多執行緒是一種複雜但強大的機制，可以顯著提升程序性能。在使用多執行緒時，需要注意同步問題，確保程序的正確性和穩定性。

關於作者

卡哥
卡哥
我是Oscar (卡哥)，前Yahoo Lead Engineer、高智商同好組織Mensa會員，超過十年的工作經驗，服務過Yahoo關鍵字廣告業務部門、電子商務及搜尋部門，喜歡彈吉他玩音樂，也喜歡投資美股、虛擬貨幣，樂於與人分享交流！

如果對文章內容有任何問題，歡迎在底下留言讓我知道。
如果你喜歡我的文章，可以按分享按鈕，讓更多的人看見我的文章。