Java線程並發編程

Java是一種面向對象的編程語言，因為其具備良好的可移植性和安全性，開發人員廣泛使用它開發各種類型的應用程序。Java的並發編程技術非常重要，因為它有助於提高應用程序的性能以及代碼執行的效率，並且確保多個線程在同時工作時不會出現問題。本文將通過不同的方面，深入探討Java線程並發編程。

一、多線程基礎

多線程是指一個程序中有兩個或多個線程同時運行，每個線程執行不同的任務。Java中的多線程技術是通過Thread類和Runnable介面來實現的。Thread類代表了一個線程，而Runnable介面是一個任務的執行狀態。以下是Java實現多線程的示例:

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
    }
}

在上面的代碼中，我們創建了一個MyThread類，該類繼承自Thread類。然後我們覆蓋了run()方法並在其中列印一條消息。在main()方法中，我們創建了一個MyThread類並開始運行它。

二、線程同步

在Java中，線程同步確保多個線程訪問共享資源是有序的。線程同步可以通過synchronized關鍵字來實現。以下是線程同步的基本示例代碼:

class SharedResource {
    int value;
    synchronized void setValue(int value){
        this.value = value;
    }
    synchronized int getValue(){
        return value;
    }
}

class MyThread1 extends Thread {
    SharedResource s;
    MyThread1(SharedResource s){
        this.s = s;
    }
    public void run(){
        s.setValue(10);
    }
}

class MyThread2 extends Thread {
    SharedResource s;
    MyThread2(SharedResource s){
        this.s = s;
    }
    public void run(){
        int value = s.getValue();
        System.out.println(value);
    }
}

public class Main {
    public static void main(String[] args) {
        SharedResource s = new SharedResource();
        MyThread1 t1 = new MyThread1(s);
        MyThread2 t2 = new MyThread2(s);
        t1.start();
        t2.start();
    }
}

在上述代碼中，我們定義了一個名為SharedResource的類，該類包含兩個方法，setValue()和getValue()。在setValue()方法中，我們使用synchronized關鍵字來確保線程同步，以避免線程之間發生錯誤。在MyThread1類和MyThread2類中，我們分別使用了SharedResource類中的setValue()方法和getValue()方法。

三、死鎖

當兩個或多個線程試圖鎖定資源時，它們可能會定位到不同的資源，進而導致死鎖。死鎖是非常嚴重的問題，因為它會導致應用程序停止響應。以下是死鎖的示例代碼：

class Resource1 {
    synchronized void execute(Resource2 res2){
        System.out.println("Resource1 - executing.");
        res2.execute();
    }
    synchronized void execute(){
        System.out.println("Resource1 - executing.");
    }
}

class Resource2 {
    synchronized void execute(Resource1 res1){
        System.out.println("Resource2 - executing.");
        res1.execute();
    }
    synchronized void execute(){
        System.out.println("Resource2 - executing.");
    }
}

public class Main {
    public static void main(String[] args) {
        Resource1 res1 = new Resource1();
        Resource2 res2 = new Resource2();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                res1.execute(res2);
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                res2.execute(res1);
            }
        });
        t1.start();
        t2.start();
    }
}

在上面的代碼中，我們定義了兩個資源，Resource1和Resource2。在每個資源中，我們實現了兩個不同的execute()方法。我們創建了兩個線程，並讓它們同時運行execute()方法。當線程t1運行Resource1中的execute()方法時，它會嘗試獲取Resource2的鎖。但是，Resource2的execute()方法已經在執行中，使得t1無法獲取Resource2的鎖，從而發生了死鎖。同樣的情況也發生在t2中。

四、線程池

線程池是一種可以重用線程執行多個任務的機制，它可以在需要時調用線程，而不是一直創建新線程。使用線程池可以提高應用程序的性能、可伸縮性和吞吐量。以下是使用Java線程池的示例代碼:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
class MyTask implements Runnable{
    private int taskId;
    public MyTask(int taskId) {
        this.taskId = taskId;
    }
    public void run() {
        System.out.println("Task ID : " + this.taskId + " performed by " 
            + Thread.currentThread().getName());
    }
}
 
public class Main{
    public static void main(String[] args) {
        int numOfTasks = 10;
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 1; i <= numOfTasks; i++) {
            executor.submit(new MyTask(i));
        }
        executor.shutdown();
    }
}

在上面的代碼中，我們創建了一個名為MyTask的類，該類實現了Runnable介面。在main()方法中，我們創建了一個執行任務的線程池，並將MyTask分配給它。在for循環中，我們創建了10個任務，並將它們添加到線程池的任務隊列中。當我們運行代碼時，我們可以看到5個線程在執行任務，並且很快便完成了所有任務，因為它們不斷地重用了線程。

五、死鎖的避免

為了避免死鎖，我們需要寫出良好的代碼，確保它們正確地並發工作。以下是一些減輕死鎖的方法：

1. 獲取鎖的順序：線程應該按照固定的順序獲取鎖。這樣可以避免出現循環依賴，最終導致死鎖。

2. 限制鎖持有時間：線程應該儘快釋放它們所持有的鎖，以避免其他線程需要等待很長時間才能獲取它們。這樣可以減少持有鎖的風險，從而減少死鎖的可能性。

3. 使用tryLock()方法：除了synchronized關鍵字外，Java還提供了一個tryLock()方法，該方法嘗試獲取鎖，但不會阻塞線程。如果鎖可用，則線程會立即獲取鎖，並繼續執行任務；否則線程將繼續執行其他任務。

4. 使用鎖的等待和通知機制：Java中的wait()和notify()方法就是為了避免死鎖而設計的。wait()方法告訴線程等待並釋放鎖，而notify()方法通知其他線程可以競爭鎖。

六、總結

在Java中使用並發編程技術可以提高應用程序的性能和效率，但也會帶來許多問題，如死鎖、並發訪問和線程同步。理解這些問題並使用正確的技術來解決它們是極為重要的。本文介紹了Java多線程的基礎知識、線程同步、死鎖、線程池和死鎖的避免方法。