多線程是 Java 中一個強大的概念，它允許我們在單個進程中同時運行多個線程。對于開發響應迅速且高效的應用程序來說，這一點至關重要，尤其是在當今的多核處理器環境中。在這份全面的指南中，我們將深入探討多線程，涵蓋理論和實際實現，使我們精通 Java 編程的這一重要方面。

什么是多線程？

多線程是一種編程概念，允許單個進程同時執行多個線程。線程是進程中的輕量級子進程，它們共享相同的內存空間，但可以獨立運行。每個線程代表一個單獨的控制流，使得在單個程序中同時執行多個任務成為可能。

重點：

• 線程是進程的較小單元，共享相同的內存空間。
• 線程可以被視為獨立的、并行的執行路徑。
• 多線程能夠高效利用多核處理器。

為什么使用多線程？

多線程具有多個優勢，使其成為軟件開發中的一個有價值的工具：

• 提高響應性：多線程允許應用程序在執行資源密集型任務時仍能對用戶輸入保持響應。例如，一個文本編輯器可以在后臺執行拼寫檢查的同時繼續響應用戶操作。
• 增強性能：多線程程序可以利用多核處理器，從而帶來更好的性能。任務可以在多個線程之間分配，加速計算。
• 資源共享：線程可以在同一進程內共享數據和資源，這可以導致更高效的內存使用。在內存密集型應用程序中，這一點可能至關重要。
• 并發：多線程實現任務的并發執行，使得同時管理多個任務更加容易。例如，一個 Web 服務器可以使用線程同時處理多個客戶端請求。

術語和概念

為了理解多線程，掌握以下關鍵概念至關重要：

• 線程：線程是進程內最小的執行單元。單個進程中可以存在多個線程，并且它們共享相同的內存空間。
• 進程：進程是在其內存空間中運行的獨立程序。它可以由一個或多個線程組成。
• 并發：并發是指在重疊的時間間隔內執行多個線程。它允許任務看起來像是同時執行。
• 并行：并行涉及多個線程或進程的實際同時執行，通常在多核處理器上。它實現真正的同時執行。
• 競爭條件：當兩個或多個線程同時訪問共享數據時，就會發生競爭條件，最終結果取決于執行的時間和順序。它可能導致不可預測的行為和錯誤。
• 同步：同步是一種用于協調和控制對共享資源的訪問的機制。它通過只允許一個線程在同一時間訪問資源來防止競爭條件。
• 死鎖：死鎖是一種兩個或多個線程因為彼此等待對方釋放資源而無法繼續執行的情況。它可能導致系統凍結。

在 Java 中創建線程

• 擴展Thread類
• 實現Runnable接口

在 Java 中，我們可以通過兩種主要方式創建線程：通過擴展Thread類或實現Runnable接口。這兩種方法都允許我們定義在新線程中運行的代碼。

擴展Thread類：

要通過擴展Thread類創建線程，我們需要創建一個新類，該類繼承自Thread并覆蓋run()方法。run()方法包含當線程啟動時將執行的代碼。以下是一個例子：

class MyThread extends Thread {
    public void run() {
        // 新線程中要執行的代碼
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread " + Thread.currentThread().getId() + ": Count " + i);
        }
    }
}
public class ThreadExample {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        thread1.start(); // 啟動第一個線程
        thread2.start(); // 啟動第二個線程
    }
}

在這個例子中，我們通過擴展Thread類創建了MyThread類。run()方法包含了新線程中要執行的代碼。我們創建了兩個MyThread的實例，并使用start()方法啟動它們。

實現Runnable接口：

另一種通常更靈活的創建線程的方法是實現Runnable接口。這種方法允許我們將線程的行為與其結構分離，使得更容易重用和擴展。以下是一個例子：

class MyRunnable implements Runnable {
    public void run() {
        // 新線程中要執行的代碼
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread " + Thread.currentThread().getId() + ": Count " + i);
        }
    }
}
public class ThreadExample {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);
        thread1.start(); // 啟動第一個線程
        thread2.start(); // 啟動第二個線程
    }
}

在這個例子中，我們創建了一個實現Runnable接口的MyRunnable類。run()方法包含了新線程中要執行的代碼。我們創建了兩個Thread實例，將MyRunnable實例作為構造函數參數傳遞。然后，我們啟動這兩個線程。

線程生命周期：

Java 中的線程在其生命周期中經歷各種狀態：

• 新建：當一個線程被創建但尚未啟動時。
• 可運行：線程已準備好運行，正在等待輪到它執行。
• 運行：線程正在積極執行其代碼。
• 阻塞/等待：線程暫時不活動，通常是由于等待資源或事件。
• 終止：線程已完成執行并已終止。

理解線程生命周期對于在多線程應用程序中進行正確的線程管理和同步至關重要。

使用多個線程

在使用多個線程時，我們需要注意各種挑戰和概念，包括線程干擾、死鎖、線程優先級和線程組。

線程干擾：

當多個線程同時訪問共享數據時，就會發生線程干擾，導致意外和不正確的結果。為了避免線程干擾，我們可以使用同步機制，如synchronized塊或方法，以確保一次只有一個線程訪問共享數據。這里有一個簡單的例子說明線程干擾：

class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public synchronized int getCount() {
        return count;
    }
}
public class ThreadInterferenceExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("Final Count: " + counter.getCount());
    }
}

在這個例子中，兩個線程（thread1和thread2）同時增加一個共享計數器。為了防止干擾，我們使用同步方法來增加和獲取計數器的值。

死鎖和解決方案：

當兩個或多個線程因為彼此等待對方釋放資源而無法繼續執行時，就會發生死鎖。死鎖可能很難診斷和修復。防止死鎖的策略包括使用正確的鎖定順序、超時和死鎖檢測算法。這里是一個潛在死鎖情況的高級示例：

class Resource {
    public synchronized void method1(Resource other) {
        // 做一些事情
        other.method2(this);
        // 做一些事情
    }
    public synchronized void method2(Resource other) {
        // 做一些事情
        other.method1(this);
        // 做一些事情
    }
}
public class DeadlockExample {
    public static void main(String[] args) {
        Resource resource1 = new Resource();
        Resource resource2 = new Resource();
        Thread thread1 = new Thread(() -> resource1.method1(resource2));
        Thread thread2 = new Thread(() -> resource2.method1(resource1));
        thread1.start();
        thread2.start();
    }
}

在這個例子中，thread1調用resource1的method1，而thread2調用resource2的method1。兩個方法隨后都嘗試獲取另一個資源的鎖，導致潛在的死鎖情況。

線程優先級和組：

Java 允許我們設置線程優先級，以影響 Java 虛擬機（JVM）的線程調度程序執行線程的順序。具有較高優先級的線程會被優先考慮，盡管謹慎使用線程優先級很重要，因為它們在不同的 JVM 實現中可能表現不一致。此外，我們可以將線程分組以進行更好的管理和控制。

Thread thread1 = new Thread(() -> {
    // 線程 1 的邏輯
});
Thread thread2 = new Thread(() -> {
    // 線程 2 的邏輯
});
thread1.setPriority(Thread.MAX_PRIORITY);
thread2.setPriority(Thread.MIN_PRIORITY);
ThreadGroup group = new ThreadGroup("MyThreadGroup");
Thread thread3 = new Thread(group, () -> {
    // 線程 3 的邏輯
});

在這個例子中，我們為thread1和thread2設置線程優先級，并為thread3創建一個名為“MyThreadGroup”的線程組。線程優先級范圍從Thread.MIN_PRIORITY（1）到Thread.MAX_PRIORITY（10）。

理解并有效地管理線程干擾、死鎖、線程優先級和線程組在 Java 中使用多個線程時至關重要。

Java 的并發實用工具

Java 提供了一組強大的并發實用工具，簡化了多線程應用程序的開發。Java 并發實用工具的三個基本組件是執行器框架、線程池以及Callable和Future。

執行器框架：

執行器框架是一個用于在多線程環境中異步管理任務執行的抽象層。它將任務提交與任務執行解耦，使我們能夠專注于需要完成的任務，而不是如何執行它。

以下是如何使用執行器框架執行任務的示例：

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
public class ExecutorExample {
    public static void main(String[] args) {
        Executor executor = Executors.newSingleThreadExecutor();
        Runnable task = () -> {
            System.out.println("Task is executing...");
        };
        executor.execute(task);
    }
}

在這個例子中，我們使用Executors.newSingleThreadExecutor()創建一個執行器，它創建一個單線程執行器。然后，我們提交一個Runnable任務以異步執行。

線程池：

線程池是一種用于管理和重用固定數量的線程來執行任務的機制。與為每個任務創建一個新線程相比，它們提供了更好的性能，因為減少了線程創建和銷毀的開銷。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Runnable task1 = () -> {
            System.out.println("Task 1 is executing...");
        };
        Runnable task2 = () -> {
            System.out.println("Task 2 is executing...");
        };
        executorService.submit(task1);
        executorService.submit(task2);
        executorService.shutdown();
    }
}

在這個例子中，我們創建一個固定大小的線程池，有兩個線程，并提交兩個任務執行。當不再需要時，調用shutdown方法優雅地關閉線程池。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Runnable task1 = () -> {
            System.out.println("Task 1 is executing...");
        };
        Runnable task2 = () -> {
            System.out.println("Task 2 is executing...");
        };
        executorService.submit(task1);
        executorService.submit(task2);
        executorService.shutdown();
    }
}

Callable接口類似于Runnable，但它可以返回結果或拋出異常。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;

public class CallableAndFutureExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Callable<Integer> task = () -> {
            Thread.sleep(2000);
            return 42;
        };
        Future<Integer> future = executorService.submit(task);
        System.out.println("Waiting for the result...");
        Integer result = future.get();
        System.out.println("Result: " + result);
        executorService.shutdown();
    }
}

這些 Java 并發實用工具為我們的應用程序提供了一種強大而高效的方式來管理多線程任務、線程池和異步計算。

高級多線程

在高級多線程中，我們更深入地探討管理線程、處理同步以及利用 Java 中的高級并發特性的復雜性。

守護線程：

守護線程是在 Java 應用程序后臺運行的后臺線程。它們通常用于非關鍵任務，并且在主程序完成執行時不會阻止應用程序退出。

Thread daemonThread = new Thread(() -> {
    while (true) {
        // 執行后臺任務
    }
});
daemonThread.setDaemon(true); // 設置為守護線程
daemonThread.start();

線程局部變量：

線程局部變量是每個線程本地的變量。它們允許我們存儲特定于特定線程的數據，確保每個線程都有自己獨立的變量副本。

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadLocalExample {
    public static void main(String[] args) {
        ThreadLocal<AtomicInteger> threadLocal = ThreadLocal.withInitial(AtomicInteger::new);
        Runnable task = () -> {
            AtomicInteger value = threadLocal.get();
            value.incrementAndGet();
            System.out.println("Thread " + Thread.currentThread().getName() + " value: " + value);
            threadLocal.remove();
        };
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        thread1.start();
        thread2.start();
    }
}

線程狀態（等待、定時等待、阻塞）：

線程可以處于不同的狀態，包括等待、定時等待和阻塞。這些狀態代表線程正在等待資源或條件改變的各種情況。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadStateExample {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        Runnable waitingTask = () -> {
            lock.lock();
            try {
                System.out.println("Thread waiting...");
                condition.await();
                System.out.println("Thread resumed.");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                lock.unlock();
            }
        };
        Runnable signalingTask = () -> {
            lock.lock();
            try {
                System.out.println("Signaling thread...");
                condition.signal();
            } finally {
                lock.unlock();
            }
        };
        Thread waitingThread = new Thread(waitingTask);
        Thread signalingThread = new Thread(signalingTask);
        waitingThread.start();
        signalingThread.start();
    }
}

線程間通信：

線程間通信允許線程協調并交換信息。這包括使用wait、notify和notifyAll方法來同步線程。

class SharedResource {
    private boolean flag = false;

    public synchronized void waitForSignal() throws InterruptedException {
        while (!flag) {
            wait();
        }
    }

    public synchronized void setSignal() {
        flag = true;
        notifyAll();
    }
}

public class ThreadCommunicationExample {
    public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();
        Thread waitingThread = new Thread(() -> {
            try {
                sharedResource.waitForSignal();
                System.out.println("Waiting thread received signal.");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        Thread signalingThread = new Thread(() -> {
            sharedResource.setSignal();
            System.out.println("Signaling thread sent signal.");
        });
        waitingThread.start();
        signalingThread.start();
    }
}

并發集合：

并發集合是線程安全的數據結構，允許多個線程同時訪問和修改它們，而不會導致數據損壞或同步問題。一些例子包括ConcurrentHashMap、ConcurrentLinkedQueue和CopyOnWriteArrayList。

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CopyOnWriteArrayList;

public class ConcurrentCollectionsExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();
        concurrentHashMap.put("key1", 1);
        concurrentHashMap.put("key2", 2);
        System.out.println("ConcurrentHashMap: " + concurrentHashMap);

        ConcurrentLinkedQueue<String> concurrentLinkedQueue = new ConcurrentLinkedQueue<>();
        concurrentLinkedQueue.add("item1");
        concurrentLinkedQueue.add("item2");
        System.out.println("ConcurrentLinkedQueue: " + concurrentLinkedQueue);

        CopyOnWriteArrayList<String> copyOnWriteArrayList = new CopyOnWriteArrayList<>();
        copyOnWriteArrayList.add("element1");
        copyOnWriteArrayList.add("element2");
        System.out.println("CopyOnWriteArrayList: " + copyOnWriteArrayList);
    }
}

線程安全和最佳實踐：

在多線程應用程序中確保線程安全至關重要。本節涵蓋最佳實踐，如使用不可變對象、原子類以及避免字符串駐留，以編寫健壯且線程安全的代碼。

import java.util.concurrent.atomic.AtomicInteger;

class ImmutableObject {
    private final int value;

    public ImmutableObject(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

public class ThreadSafetyBestPracticesExample {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(0);
        ImmutableObject immutableObject = new ImmutableObject(10);

        Runnable incrementTask = () -> {
            atomicInteger.incrementAndGet();
            System.out.println("Atomic integer value: " + atomicInteger.get());
        };

        Runnable readImmutableTask = () -> {
            System.out.println("Immutable object value: " + immutableObject.getValue());
        };

        Thread thread1 = new Thread(incrementTask);
        Thread thread2 = new Thread(readImmutableTask);
        thread1.start();
        thread2.start();
    }
}

Java 中的并行：

并行涉及并發執行任務以提高性能。Java 在 Java 8 中提供了并行流和CompletableFuture用于異步編程等功能。

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

public class JavaParallelismExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        List<Integer> squaredNumbers = numbers.parallelStream()
               .map(n -> n * n)
               .collect(Collectors.toList());
        System.out.println("Squared numbers using parallel stream: " + squaredNumbers);

        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Asynchronous task using CompletableFuture.");
        });
        future.join();
    }
}

真實世界的多線程：

本節深入探討多線程的實際應用，包括實現 Web 服務器以及在游戲開發中使用多線程。

// Web 服務器示例（簡化版）
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class SimpleWebServerExample {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("Web server started on port 8080.");
            while (true) {
                Socket clientSocket = serverSocket.accept();
                handleRequest(clientSocket);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handleRequest(Socket clientSocket) {
        try {
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
            out.println("HTTP/1.1 200 OK");
            out.println("Content-Type: text/html");
            out.println();
            out.println("<html><body>Hello from simple web server!</body></html>");
            clientSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

這些高級多線程主題為開發人員提供了構建高效、并發和可擴展的 Java 應用程序所需的知識和技能。每個主題都附有示例以說明概念和技術。

若你想提升Java技能，可關注我們的Java培訓課程。