public abstract class InterruptibleTask implements Runnable {
    protected volatile boolean stopped = false;
    protected abstract void doWork() throws Exception;
    protected void cleanup() { /* 資源清理 */ }
    @Override
    public void run() {
        try { while (!stopped) doWork(); }
        catch (InterruptedException ie) { Thread.currentThread().interrupt(); }
        catch (Exception e) { e.printStackTrace(); }
        finally { cleanup(); }
    }
    public void stop() { stopped = true; }
}

public class ThreadInterrupter {
    public static void interruptAndJoin(Thread t, long timeoutMs);
}

// 文件：InterruptibleTask.java
package com.example.threadinterrupt;
 
public abstract class InterruptibleTask implements Runnable {
    // 可選的主動停止標志
    protected volatile boolean stopped = false;
 
    /** 子類實現具體工作邏輯，支持拋出 InterruptedException */
    protected abstract void doWork() throws Exception;
 
    /** 資源清理（流/鎖/注冊等），可由子類覆蓋 */
    protected void cleanup() { }
 
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.printf("[%s] 開始執(zhí)行%n", name);
        try {
            while (!stopped && !Thread.currentThread().isInterrupted()) {
                doWork();
            }
        } catch (InterruptedException ie) {
            // 恢復中斷狀態(tài)，允許外層檢測
            Thread.currentThread().interrupt();
            System.out.printf("[%s] 捕獲 InterruptedException，準備退出%n", name);
        } catch (Exception e) {
            System.err.printf("[%s] 出現異常: %s%n", name, e);
            e.printStackTrace();
        } finally {
            cleanup();
            System.out.printf("[%s] 已退出%n", name);
        }
    }
 
    /** 主動請求停止（可選） */
    public void stop() {
        stopped = true;
    }
}
 
// ----------------------------------------------------------------
// 文件：ThreadInterrupter.java
package com.example.threadinterrupt;
 
public class ThreadInterrupter {
    /**
     * 中斷線程并等待退出
     * @param t         目標線程
     * @param timeoutMs 等待退出超時時間（毫秒）
     */
    public static void interruptAndJoin(Thread t, long timeoutMs) {
        System.out.printf("[Interrupter] 中斷線程 %s%n", t.getName());
        t.interrupt();
        try {
            t.join(timeoutMs);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        if (t.isAlive()) {
            System.err.printf("[Interrupter] 線程 %s 未能在 %d ms 內退出%n",
                    t.getName(), timeoutMs);
        } else {
            System.out.printf("[Interrupter] 線程 %s 已退出%n", t.getName());
        }
    }
}
 
// ----------------------------------------------------------------
// 文件：BusyLoopTask.java
package com.example.threadinterrupt;
 
public class BusyLoopTask extends InterruptibleTask {
    private int counter = 0;
    @Override
    protected void doWork() throws InterruptedException {
        // 模擬業(yè)務：每100ms自增一次
        Thread.sleep(100);
        System.out.printf("[BusyLoop] %s：計數 %d%n",
                Thread.currentThread().getName(), ++counter);
    }
}
 
// ----------------------------------------------------------------
// 文件：BlockingQueueTask.java
package com.example.threadinterrupt;
 
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
 
public class BlockingQueueTask extends InterruptibleTask {
    private final BlockingQueue<String> queue = new LinkedBlockingQueue<>();
 
    public BlockingQueueTask() {
        // 先放一個元素供 take
        queue.offer("初始數據");
    }
 
    @Override
    protected void doWork() throws InterruptedException {
        String data = queue.take();  // 阻塞等待
        System.out.printf("[BlockingQueue] %s：取到數據 %s%n",
                Thread.currentThread().getName(), data);
    }
}
 
// ----------------------------------------------------------------
// 文件：IOReadTask.java
package com.example.threadinterrupt;
 
import java.io.*;
 
public class IOReadTask extends InterruptibleTask {
    private PipedInputStream in;
    private PipedOutputStream out;
 
    public IOReadTask() throws IOException {
        in = new PipedInputStream();
        out = new PipedOutputStream(in);
        // 啟動寫線程，模擬持續(xù)寫入
        new Thread(() -> {
            try {
                int i = 0;
                while (true) {
                    out.write(("msg" + i++ + "\n").getBytes());
                    Thread.sleep(200);
                }
            } catch (Exception ignored) { }
        }, "Writer").start();
    }
 
    @Override
    protected void doWork() throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
        String line = reader.readLine(); // 阻塞在 readLine
        System.out.printf("[IORead] %s：讀到 %s%n",
                Thread.currentThread().getName(), line);
    }
 
    @Override
    protected void cleanup() {
        try { in.close(); out.close(); } catch (IOException ignored) { }
        System.out.printf("[IORead] %s：已關閉流%n", Thread.currentThread().getName());
    }
}
 
// ----------------------------------------------------------------
// 文件：Main.java
package com.example.threadinterrupt;
 
public class Main {
    public static void main(String[] args) throws Exception {
        // 創(chuàng)建并啟動任務
        BusyLoopTask busy = new BusyLoopTask();
        Thread t1 = new Thread(busy, "BusyLoop-Thread");
        t1.start();
 
        BlockingQueueTask bq = new BlockingQueueTask();
        Thread t2 = new Thread(bq, "BlockingQueue-Thread");
        t2.start();
 
        IOReadTask io = new IOReadTask();
        Thread t3 = new Thread(io, "IORead-Thread");
        t3.start();
 
        // 運行 2 秒后中斷
        Thread.sleep(2000);
        ThreadInterrupter.interruptAndJoin(t1, 500);
        ThreadInterrupter.interruptAndJoin(t2, 500);
        ThreadInterrupter.interruptAndJoin(t3, 500);
    }
}