如何優雅地處理Java多線程中的中斷和異常

作者：了不起 2024-09-26 10:51:51

正確處理線程中斷和異常對于編寫健壯的多線程程序至關重要。通過定期檢查中斷狀態、清理資源、使用??ExecutorService??和??Future??等工具，我們可以提高程序的穩定性和健壯性。

前言

在Java多線程編程中，正確處理線程中斷和異常對于確保程序的穩定性和健壯性至關重要。本文將介紹一些關鍵的最佳實踐，并提供示例代碼來說明這些觀點。

1. 理解中斷機制

Java中的中斷機制允許一個線程通知另一個線程應該停止當前的操作。當一個線程被中斷時，它的中斷狀態會被設置為true。線程可以通過檢查自己的中斷狀態或捕獲InterruptedException來響應中斷。

示例代碼：理解中斷機制

public class InterruptDemo implements Runnable {
    public void run() {
        try {
            while (!Thread.currentThread().isInterrupted()) {
                // 執行任務
                Thread.sleep(1000);
                System.out.println("Running...");
            }
        } catch (InterruptedException e) {
            System.out.println("Interrupted during sleep.");
        }
        System.out.println("Finished execution.");
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new InterruptDemo());
        thread.start();
        Thread.sleep(2500);
        thread.interrupt(); // 主線程中斷子線程
    }
}

2. 清理資源，使用finally塊

無論線程因為中斷還是其他原因結束，都應該確保釋放所有占用的資源。在try-catch塊中使用finally塊來確保資源總是被釋放。

示例代碼：使用finally塊

public class FinallyBlockExample implements Runnable {
    public void run() {
        try {
            // 模擬長時間運行的任務
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            System.out.println("Interrupted during sleep.");
            Thread.currentThread().interrupt();
        } finally {
            System.out.println("Finally block executed.");
            // 清理資源
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new FinallyBlockExample());
        thread.start();
        Thread.sleep(2500);
        thread.interrupt();
    }
}

3. 避免在finally塊中再次中斷

不要在finally塊中調用Thread.currentThread().interrupt()，因為這會重新設置中斷狀態。

示例代碼：避免在finally塊中再次中斷

public class AvoidReinterruptInFinally implements Runnable {
    public void run() {
        try {
            // 模擬長時間運行的任務
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            System.out.println("Interrupted during sleep.");
        } finally {
            System.out.println("Resources are cleaned up.");
            // 注意：不要在這里調用 interrupt()
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new AvoidReinterruptInFinally());
        thread.start();
        Thread.sleep(2500);
        thread.interrupt();
    }
}

4. 使用ExecutorService管理線程

ExecutorService提供了一種優雅的方式來啟動、管理和終止線程。

示例代碼：使用ExecutorService

import java.util.concurrent.*;

public class ExecutorServiceExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(() -> {
            try {
                // 執行任務
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                System.out.println("Task was interrupted.");
            }
        });

        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow(); // 取消當前執行的任務
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

5. 使用Future跟蹤任務

Future對象可以用于跟蹤異步執行的操作。

示例代碼：使用Future跟蹤任務

import java.util.concurrent.*;

public class FutureTrackingExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<?> future = executor.submit(() -> {
            try {
                // 執行任務
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                System.out.println("Task was interrupted.");
            }
        });

        try {
            if (future.isDone()) {
                System.out.println("Task completed.");
            } else {
                future.cancel(true); // 取消任務
            }
        } finally {
            executor.shutdown();
        }
    }
}

6. 正確處理ConcurrentModificationException

在并發環境下，不應該捕獲ConcurrentModificationException，因為這通常意味著代碼中存在并發問題。

示例代碼：正確處理ConcurrentModificationException

import java.util.concurrent.*;

public class ConcurrentModificationExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        List<Integer> list = new ArrayList<>();

        executor.submit(() -> {
            list.add(1);
        });

        executor.submit(() -> {
            list.add(2);
        });

        executor.shutdown();
        try {
            executor.awaitTermination(1, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // 這里不應該捕獲 ConcurrentModificationException
        for (int num : list) {
            System.out.println(num);
        }
    }
}

7. 使用不可變對象

不可變對象是線程安全的，因為它們的狀態在創建后不能改變。

示例代碼：使用不可變對象

import java.util.Collections;

public class ImmutableObjectExample {
    public static void main(String[] args) {
        List<String> immutableList = Collections.unmodifiableList(new ArrayList<>(Arrays.asList("A", "B", "C")));
        
        // 嘗試修改不可變列表將拋出 UnsupportedOperationException
        try {
            immutableList.add("D");
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot modify an immutable list.");
        }
    }
}

8. 使用同步工具

使用CountDownLatch、CyclicBarrier、Semaphore等同步工具來控制線程的執行順序。

示例代碼：使用同步工具

import java.util.concurrent.*;

public class SynchronizationToolsExample {
    public static void main(String[] args) throws InterruptedException {
        int numberOfThreads = 5;
        CountDownLatch latch = new CountDownLatch(numberOfThreads);

        for (int i = 0; i < numberOfThreads; i++) {
            new Thread(() -> {
                try {
                    // 模擬任務
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    latch.countDown();
                }
            }).start();
        }

        latch.await(); // 等待所有線程完成
        System.out.println("All threads have finished execution.");
    }
}

9. 避免使用stop方法

Thread.stop()方法已經被廢棄，因為它不安全。

示例代碼：避免使用stop方法

public class AvoidStopMethodExample implements Runnable {
    private volatile boolean running = true;

    @Override
    public void run() {
        while (running) {
            // 執行任務
        }
    }

    public void stopRunning() {
        running = false;
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new AvoidStopMethodExample());
        thread.start();

        try
 {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        AvoidStopMethodExample example = (AvoidStopMethodExample) thread;
        example.stopRunning();
    }
}

10. 使用volatile關鍵字

當多個線程訪問同一個變量時，應該使用volatile關鍵字來確保變量的可見性。

示例代碼：使用volatile關鍵字

public class VolatileKeywordExample implements Runnable {
    private volatile boolean running = true;

    @Override
    public void run() {
        while (running) {
            // 執行任務
        }
    }

    public void stop() {
        running = false;
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new VolatileKeywordExample());
        thread.start();

        Thread.sleep(2000);
        ((VolatileKeywordExample) thread).stop();
    }
}

11. 使用Atomic類

對于原子操作，如計數器，可以使用AtomicInteger等java.util.concurrent.atomic包中的類。

示例代碼：使用Atomic類

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicClassExample {
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        int numberOfThreads = 100;
        ExecutorService executor = Executors.newFixedThreadPool(10);

        for (int i = 0; i < numberOfThreads; i++) {
            executor.submit(() -> {
                counter.incrementAndGet();
            });
        }

        executor.shutdown();
        try {
            executor.awaitTermination(1, TimeUnit.SECONDS);
            System.out.println("Counter value: " + counter.get());
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

小結

正確處理線程中斷和異常對于編寫健壯的多線程程序至關重要。通過定期檢查中斷狀態、清理資源、使用ExecutorService和Future等工具，我們可以提高程序的穩定性和健壯性。記住，測試并發代碼同樣重要，以確保在多線程環境中程序能夠正確運行。希望這篇文章能幫助你更好地理解如何在Java中優雅地處理線程中斷和異常。

責任編輯：武曉燕來源： Java面試教程

Java 多線程編寫