/**
 * 繼承Thread類(lèi)創(chuàng)建線程
 */
public class MyThread extends Thread {
    // 線程名稱(chēng)
    private String threadName;
    public MyThread(String threadName) {
        this.threadName = threadName;
    }
    // 重寫(xiě)run方法，定義線程執(zhí)行邏輯
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(threadName + " 執(zhí)行：" + i);
            // 模擬線程執(zhí)行耗時(shí)操作
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        // 創(chuàng)建線程對(duì)象
        MyThread thread1 = new MyThread("線程A");
        MyThread thread2 = new MyThread("線程B");
        // 啟動(dòng)線程：注意是調(diào)用start()方法，不是run()方法
        thread1.start();
        thread2.start();
    }
}

/**
 * 實(shí)現(xiàn)Runnable接口創(chuàng)建線程
 */
public class MyRunnable implements Runnable {
    private String taskName;
    public MyRunnable(String taskName) {
        this.taskName = taskName;
    }
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(taskName + " 執(zhí)行：" + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        // 創(chuàng)建任務(wù)對(duì)象
        MyRunnable task1 = new MyRunnable("任務(wù)A");
        MyRunnable task2 = new MyRunnable("任務(wù)B");
        // 創(chuàng)建線程對(duì)象，傳入任務(wù)
        Thread thread1 = new Thread(task1);
        Thread thread2 = new Thread(task2);
        // 啟動(dòng)線程
        thread1.start();
        thread2.start();
    }
}

/**
 * 多線程共享資源：模擬售票系統(tǒng)
 */
public class TicketRunnable implements Runnable {
    // 共享資源：10張票
    private int ticketNum = 10;
    @Override
    public void run() {
        while (ticketNum > 0) {
            // 模擬售票耗時(shí)
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " 售出第 " + ticketNum-- + " 張票");
        }
    }
    public static void main(String[] args) {
        // 一個(gè)任務(wù)對(duì)象，多個(gè)線程共享
        TicketRunnable ticketTask = new TicketRunnable();
        // 三個(gè)線程模擬三個(gè)售票窗口
        Thread window1 = new Thread(ticketTask, "窗口1");
        Thread window2 = new Thread(ticketTask, "窗口2");
        Thread window3 = new Thread(ticketTask, "窗口3");
        window1.start();
        window2.start();
        window3.start();
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
/**
 * 實(shí)現(xiàn)Callable接口創(chuàng)建線程（帶返回值）
 */
public class MyCallable implements Callable<Integer> {
    // 計(jì)算1到n的累加和
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
            System.out.println("計(jì)算中：" + i + "，當(dāng)前和為：" + sum);
            Thread.sleep(200);
        }
        return sum;
    }
    public static void main(String[] args) throws Exception {
        // 創(chuàng)建Callable任務(wù)
        MyCallable callableTask = new MyCallable(10);
        // 用FutureTask包裝，用于獲取返回值
        FutureTask<Integer> futureTask = new FutureTask<>(callableTask);
        // 創(chuàng)建線程并啟動(dòng)
        Thread thread = new Thread(futureTask);
        thread.start();
        // 獲取返回值：get()方法會(huì)阻塞，直到線程執(zhí)行完成
        Integer result = futureTask.get();
        System.out.println("1到10的累加和為：" + result);
    }
}

NEW → RUNNABLE：調(diào)用 start() 方法
RUNNABLE → BLOCKED：競(jìng)爭(zhēng)鎖失敗
BLOCKED → RUNNABLE：獲取到鎖資源
RUNNABLE → WAITING：調(diào)用 wait()/join() 方法
WAITING → RUNNABLE：其他線程調(diào)用 notify()/notifyAll() 方法
RUNNABLE → TIMED_WAITING：調(diào)用 sleep(long)/wait(long) 方法
TIMED_WAITING → RUNNABLE：超時(shí)自動(dòng)喚醒或被其他線程喚醒
RUNNABLE → TERMINATED：run() 方法執(zhí)行完畢或異常終止

/**
 * 使用join方法實(shí)現(xiàn)線程順序執(zhí)行
 */
public class ThreadJoinDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread(() -> {
            for (int i = 1; i <= 3; i++) {
                System.out.println("線程A執(zhí)行：" + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread threadB = new Thread(() -> {
            for (int i = 1; i <= 3; i++) {
                System.out.println("線程B執(zhí)行：" + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 啟動(dòng)線程A
        threadA.start();
        // 等待線程A執(zhí)行完畢，再啟動(dòng)線程B
        threadA.join();
        threadB.start();
    }
}

public class UnsafeTicketDemo implements Runnable {
    private int ticketNum = 10;
    @Override
    public void run() {
        while (ticketNum > 0) {
            // 模擬網(wǎng)絡(luò)延遲，放大并發(fā)問(wèn)題
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 核心問(wèn)題：判斷和操作不是原子性的
            System.out.println(Thread.currentThread().getName() + " 售出第 " + ticketNum-- + " 張票");
        }
    }
    public static void main(String[] args) {
        UnsafeTicketDemo task = new UnsafeTicketDemo();
        new Thread(task, "窗口1").start();
        new Thread(task, "窗口2").start();
        new Thread(task, "窗口3").start();
    }
}

synchronized (鎖對(duì)象) {
    // 需要同步的代碼（操作共享資源的代碼）
}

public class SafeTicketDemo1 implements Runnable {
    private int ticketNum = 10;
    // 定義鎖對(duì)象：必須是多個(gè)線程共享的對(duì)象
    private final Object lock = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (lock) {
                if (ticketNum > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 售出第 " + ticketNum-- + " 張票");
                } else {
                    break;
                }
            }
        }
    }
    public static void main(String[] args) {
        SafeTicketDemo1 task = new SafeTicketDemo1();
        new Thread(task, "窗口1").start();
        new Thread(task, "窗口2").start();
        new Thread(task, "窗口3").start();
    }
}

public synchronized 返回值類(lèi)型 方法名(參數(shù)列表) {
    // 需要同步的代碼
}

public class SafeTicketDemo2 implements Runnable {
    private int ticketNum = 10;
    @Override
    public void run() {
        while (true) {
            if (!sellTicket()) {
                break;
            }
        }
    }
    // 同步方法：鎖定的是this對(duì)象
    private synchronized boolean sellTicket() {
        if (ticketNum > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " 售出第 " + ticketNum-- + " 張票");
            return true;
        } else {
            return false;
        }
    }
    public static void main(String[] args) {
        SafeTicketDemo2 task = new SafeTicketDemo2();
        new Thread(task, "窗口1").start();
        new Thread(task, "窗口2").start();
        new Thread(task, "窗口3").start();
    }
}

import java.util.concurrent.locks.ReentrantLock;
public class SafeTicketDemo3 implements Runnable {
    private int ticketNum = 10;
    // 創(chuàng)建可重入鎖對(duì)象
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            // 獲取鎖
            lock.lock();
            try {
                if (ticketNum > 0) {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " 售出第 " + ticketNum-- + " 張票");
                } else {
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 釋放鎖：必須放在finally塊中
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) {
        SafeTicketDemo3 task = new SafeTicketDemo3();
        new Thread(task, "窗口1").start();
        new Thread(task, "窗口2").start();
        new Thread(task, "窗口3").start();
    }
}

public ThreadPoolExecutor(
    int corePoolSize,                  // 核心線程數(shù)
    int maximumPoolSize,               // 最大線程數(shù)
    long keepAliveTime,                // 非核心線程空閑存活時(shí)間
    TimeUnit unit,                     // 時(shí)間單位
    BlockingQueue<Runnable> workQueue, // 任務(wù)隊(duì)列
    ThreadFactory threadFactory,       // 線程工廠
    RejectedExecutionHandler handler   // 拒絕策略
)

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 固定大小線程池的使用
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 1. 創(chuàng)建固定大小的線程池，核心線程數(shù)=最大線程數(shù)=3
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        // 2. 提交10個(gè)任務(wù)
        for (int i = 1; i <= 10; i++) {
            int taskId = i;
            executorService.submit(() -> {
                System.out.println("任務(wù)" + taskId + " 由線程 " + Thread.currentThread().getName() + " 執(zhí)行");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        // 3. 關(guān)閉線程池
        executorService.shutdown();
    }
}

import java.util.concurrent.*;
/**
 * 手動(dòng)創(chuàng)建線程池（推薦方式）
 */
public class CustomThreadPoolDemo {
    public static void main(String[] args) {
        // 1. 定義線程池參數(shù)
        int corePoolSize = 2;
        int maximumPoolSize = 5;
        long keepAliveTime = 60;
        TimeUnit unit = TimeUnit.SECONDS;
        // 任務(wù)隊(duì)列：容量為3的阻塞隊(duì)列
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(3);
        // 線程工廠：默認(rèn)線程工廠
        ThreadFactory threadFactory = Executors.defaultThreadFactory();
        // 拒絕策略：丟棄任務(wù)并拋出異常
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
        // 2. 創(chuàng)建線程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue,
                threadFactory,
                handler
        );
        // 3. 提交任務(wù)
        for (int i = 1; i <= 10; i++) {
            int taskId = i;
            try {
                executor.submit(() -> {
                    System.out.println("任務(wù)" + taskId + " 由線程 " + Thread.currentThread().getName() + " 執(zhí)行");
                    Thread.sleep(1000);
                });
            } catch (Exception e) {
                System.out.println("任務(wù)" + taskId + " 被拒絕：" + e.getMessage());
            }
        }
        // 4. 關(guān)閉線程池
        executor.shutdown();
    }
}

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
/**
 * 多線程文件批量下載工具
 */
public class MultiThreadFileDownloader {
    // 線程池：核心線程數(shù)2，最大線程數(shù)4
    private static final ExecutorService EXECUTOR = new ThreadPoolExecutor(
            2,
            4,
            60,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(2),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy()
    );
    // 下載狀態(tài)列表
    private static final List<String> DOWNLOAD_STATUS = new ArrayList<>();
    /**
     * 下載單個(gè)文件
     * @param fileUrl 文件URL
     * @param savePath 保存路徑
     */
    private static void downloadFile(String fileUrl, String savePath) {
        HttpURLConnection connection = null;
        InputStream in = null;
        OutputStream out = null;
        try {
            URL url = new URL(fileUrl);
            connection = (HttpURLConnection) url.openConnection();
            connection.setConnectTimeout(5000);
            connection.setReadTimeout(5000);
            // 獲取文件名
            String fileName = fileUrl.substring(fileUrl.lastIndexOf("/") + 1);
            File saveFile = new File(savePath + File.separator + fileName);
            // 讀取文件流并寫(xiě)入本地
            in = connection.getInputStream();
            out = new FileOutputStream(saveFile);
            byte[] buffer = new byte[1024 * 8];
            int len;
            while ((len = in.read(buffer)) != -1) {
                out.write(buffer, 0, len);
            }
            String successMsg = "成功：" + fileName;
            synchronized (DOWNLOAD_STATUS) {
                DOWNLOAD_STATUS.add(successMsg);
            }
            System.out.println(successMsg);
        } catch (Exception e) {
            String fileName = fileUrl.substring(fileUrl.lastIndexOf("/") + 1);
            String failMsg = "失?。? + fileName + "，原因：" + e.getMessage();
            synchronized (DOWNLOAD_STATUS) {
                DOWNLOAD_STATUS.add(failMsg);
            }
            System.out.println(failMsg);
        } finally {
            // 關(guān)閉資源
            try {
                if (out != null) out.close();
                if (in != null) in.close();
                if (connection != null) connection.disconnect();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 批量下載文件
     * @param urlList URL列表
     * @param savePath 保存路徑
     */
    public static void batchDownload(List<String> urlList, String savePath) {
        // 檢查保存路徑是否存在
        File saveDir = new File(savePath);
        if (!saveDir.exists()) {
            saveDir.mkdirs();
        }
        // 提交下載任務(wù)
        for (String url : urlList) {
            EXECUTOR.submit(() -> downloadFile(url, savePath));
        }
        // 關(guān)閉線程池
        EXECUTOR.shutdown();
        try {
            // 等待所有任務(wù)完成
            EXECUTOR.awaitTermination(1, TimeUnit.HOURS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 打印下載結(jié)果
        System.out.println("\n===== 下載完成 ======");
        for (String status : DOWNLOAD_STATUS) {
            System.out.println(status);
        }
    }
    public static void main(String[] args) {
        // 測(cè)試URL列表（替換為實(shí)際可下載的URL）
        List<String> urlList = new ArrayList<>();
        urlList.add("https://example.com/file1.txt");
        urlList.add("https://example.com/file2.jpg");
        urlList.add("https://example.com/file3.pdf");
        urlList.add("https://example.com/file4.zip");
        urlList.add("https://example.com/file5.doc");
        // 批量下載到D盤(pán)download目錄
        batchDownload(urlList, "D:\\download");
    }
}