多執行緒基礎

/** * 繼承 Thread 並覆寫 run。 * 缺點：Java 單一繼承，繼承了 Thread 就無法再繼承其他類別。 */ public class ThreadBySubclass extends Thread

@Override public void run() // 這段程式碼會在新執行緒中執行 System.out.println("執行緒名稱：" + getName());

public static void main(String[] args) ThreadBySubclass t = new ThreadBySubclass(); t.start(); // 啟動新執行緒（呼叫 run() 只是普通方法呼叫）

/** * 實作 Runnable，再交給 Thread 執行。 * Runnable 是函數式介面，可直接用 Lambda（呼應第 1 章）。 */ public class ThreadByRunnable

public static void main(String[] args)

// 方式二：具名或匿名實作 Runnable Runnable task = () -> System.out.println( "在 " + Thread.currentThread().getName() + " 中執行");

Thread t1 = new Thread(task, "worker-1"); t1.start();

// 方式三：直接把 Lambda 傳給 Thread（最精簡） new Thread(() -> System.out.println("Lambda 執行緒"), "worker-2").start();

/** * 觀察執行緒在不同時點的狀態。 */ public class ThreadStateDemo

public static void main(String[] args) throws InterruptedException

Thread t = new Thread(() -> try Thread.sleep(100); // 進入 TIMED_WAITING catch (InterruptedException e) Thread.currentThread().interrupt(); );

System.out.println("start 前：" + t.getState()); // NEW t.start(); Thread.sleep(20); // 讓 t 有機會進入 sleep System.out.println("sleep 中：" + t.getState()); // TIMED_WAITING t.join(); // 等 t 結束 System.out.println("結束後：" + t.getState()); // TERMINATED

/** * 用 join 確保主執行緒在工作執行緒完成後才繼續。 */ public class JoinDemo

public static void main(String[] args) throws InterruptedException

Thread worker = new Thread(() -> for (int i = 1; i <= 3; i++) System.out.println("工作進度：" + i); try Thread.sleep(50); catch (InterruptedException e) Thread.currentThread().interrupt(); );

worker.start(); worker.join(); // 主執行緒在此等待 worker 結束 System.out.println("工作已完成，主執行緒繼續");

/** * 守護執行緒示範：背景心跳。 * 主執行緒結束後，JVM 不等守護執行緒即關閉。 */ public class DaemonDemo

public static void main(String[] args) throws InterruptedException

Thread heartbeat = new Thread(() -> while (true) // 看似無限迴圈 System.out.println("心跳…"); try Thread.sleep(30); catch (InterruptedException e) break; );

heartbeat.setDaemon(true); // 必須在 start 前設定 heartbeat.start(); Thread.sleep(100); // 主執行緒只活這麼久 System.out.println("主執行緒結束，JVM 即將關閉");

/** * 中斷是「請求」而非「命令」：被中斷者自行檢查旗標並優雅收尾。 */ public class InterruptDemo

public static void main(String[] args) throws InterruptedException

Thread worker = new Thread(() -> // 用中斷旗標作為迴圈的結束條件 while (!Thread.currentThread().isInterrupted()) System.out.println("工作中…"); try Thread.sleep(50); catch (InterruptedException e) // sleep 被中斷會清除旗標，這裡要「恢復」旗標 Thread.currentThread().interrupt(); System.out.println("收到中斷，準備收尾"); System.out.println("已優雅結束"); );

worker.start(); Thread.sleep(160); worker.interrupt(); // 送出中斷請求 worker.join();

/** * 兩個執行緒各對 count 累加十萬次，預期二十萬。 * 但 count++ 並非原子操作，結果幾乎必定小於二十萬。 */ public class RaceCondition

static int count = 0; // 共享的可變狀態

public static void main(String[] args) throws InterruptedException

Runnable task = () -> for (int i = 0; i < 100_000; i++) count++; // 讀取、加一、寫回：三個步驟 ;

Thread t1 = new Thread(task); Thread t2 = new Thread(task); t1.start(); t2.start(); t1.join(); t2.join();

System.out.println("預期：200000，實際：" + count);

/** * 用 synchronized 保護 count++，讓它成為不可分割的原子操作。 */ public class SyncCounter

static int count = 0; static final Object lock = new Object(); // 專用的鎖物件

public static void main(String[] args) throws InterruptedException

Runnable task = () -> for (int i = 0; i < 100_000; i++) // 同步區塊：同一時刻只有一個執行緒能進入 synchronized (lock) count++; // 現在是原子操作了 ;

Thread t1 = new Thread(task); Thread t2 = new Thread(task); t1.start(); t2.start(); t1.join(); t2.join();

System.out.println("預期：200000，實際：" + count);

/** * 若 running 沒有 volatile，工作執行緒可能看不到主執行緒的修改， * 而陷入無法結束的迴圈。加上 volatile 保證可見性。 */ public class VolatileDemo

// 拿掉 volatile 這個程式可能永遠不會停止 static volatile boolean running = true;

public static void main(String[] args) throws InterruptedException

Thread worker = new Thread(() -> long n = 0; while (running) // 讀取共享旗標 n++; System.out.println("已停止，累計：" + n); );

worker.start(); Thread.sleep(50); running = false; // 主執行緒改變旗標 System.out.println("已送出停止指令"); worker.join();

import java.util.LinkedList; import java.util.Queue;

/** * 生產者消費者：以固定容量的緩衝區協調兩端。 * wait 會釋放鎖並等待，notify/notifyAll 喚醒等待者。 */ public class ProducerConsumer

static final Queue<Integer> buffer = new LinkedList<>(); static final int CAPACITY = 3; static final Object lock = new Object();

public static void main(String[] args) throws InterruptedException

Thread producer = new Thread(() -> for (int i = 1; i <= 5; i++) synchronized (lock) // 用 while 而非 if 檢查條件，防止「虛假喚醒」 while (buffer.size() == CAPACITY) waitQuietly(); buffer.add(i); System.out.println("生產：" + i); lock.notifyAll(); // 喚醒可能在等的消費者 );

Thread consumer = new Thread(() -> for (int i = 1; i <= 5; i++) synchronized (lock) while (buffer.isEmpty()) waitQuietly(); System.out.println(" 消費：" + buffer.poll()); lock.notifyAll(); // 喚醒可能在等的生產者 );

producer.start(); consumer.start(); producer.join(); consumer.join();

/** 封裝 wait 與中斷處理，讓主邏輯乾淨 */ static void waitQuietly() try lock.wait(); // 釋放鎖並等待被喚醒 catch (InterruptedException e) Thread.currentThread().interrupt();

/** * 兩個執行緒以相反順序取得兩把鎖，造成死結。 * 此程式會卡住不會結束（需手動終止）。 */ public class DeadlockDemo

static final Object lockA = new Object(); static final Object lockB = new Object();

public static void main(String[] args)

Thread t1 = new Thread(() -> synchronized (lockA) // 先拿 A System.out.println("t1 取得 A，欲取 B"); sleep(50); synchronized (lockB) // 再求 B（被 t2 佔用） System.out.println("t1 取得 B"); );

Thread t2 = new Thread(() -> synchronized (lockB) // 先拿 B System.out.println("t2 取得 B，欲取 A"); sleep(50); synchronized (lockA) // 再求 A（被 t1 佔用） System.out.println("t2 取得 A"); );

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

static void sleep(long ms) try Thread.sleep(ms); catch (InterruptedException e) Thread.currentThread().interrupt();