JAVA 多线程编程从基础原理到实战案例

/**
 * 继承Thread类创建线程
 */
public class MyThread extends Thread {
    // 线程名称
    private String threadName;
    public MyThread(String threadName) {
        this.threadName = threadName;
    }
    // 重写run方法，定义线程执行逻辑
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(threadName + " 执行：" + i);
            // 模拟线程执行耗时操作
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        // 创建线程对象
        MyThread thread1 = new MyThread("线程A");
        MyThread thread2 = new MyThread("线程B");
        // 启动线程：注意是调用start()方法，不是run()方法
        thread1.start();
        thread2.start();
    }
}

/**
 * 实现Runnable接口创建线程
 */
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 + " 执行：" + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        // 创建任务对象
        MyRunnable task1 = new MyRunnable("任务A");
        MyRunnable task2 = new MyRunnable("任务B");
        // 创建线程对象，传入任务
        Thread thread1 = new Thread(task1);
        Thread thread2 = new Thread(task2);
        // 启动线程
        thread1.start();
        thread2.start();
    }
}

/**
 * 多线程共享资源：模拟售票系统
 */
public class TicketRunnable implements Runnable {
    // 共享资源：10张票
    private int ticketNum = 10;
    @Override
    public void run() {
        while (ticketNum > 0) {
            // 模拟售票耗时
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " 售出第 " + ticketNum-- + " 张票");
        }
    }
    public static void main(String[] args) {
        // 一个任务对象，多个线程共享
        TicketRunnable ticketTask = new TicketRunnable();
        // 三个线程模拟三个售票窗口
        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;
/**
 * 实现Callable接口创建线程（带返回值）
 */
public class MyCallable implements Callable<Integer> {
    // 计算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("计算中：" + i + "，当前和为：" + sum);
            Thread.sleep(200);
        }
        return sum;
    }
    public static void main(String[] args) throws Exception {
        // 创建Callable任务
        MyCallable callableTask = new MyCallable(10);
        // 用FutureTask包装，用于获取返回值
        FutureTask<Integer> futureTask = new FutureTask<>(callableTask);
        // 创建线程并启动
        Thread thread = new Thread(futureTask);
        thread.start();
        // 获取返回值：get()方法会阻塞，直到线程执行完成
        Integer result = futureTask.get();
        System.out.println("1到10的累加和为：" + result);
    }
}

NEW → RUNNABLE：调用 start() 方法
RUNNABLE → BLOCKED：竞争锁失败
BLOCKED → RUNNABLE：获取到锁资源
RUNNABLE → WAITING：调用 wait()/join() 方法
WAITING → RUNNABLE：其他线程调用 notify()/notifyAll() 方法
RUNNABLE → TIMED_WAITING：调用 sleep(long)/wait(long) 方法
TIMED_WAITING → RUNNABLE：超时自动唤醒或被其他线程唤醒
RUNNABLE → TERMINATED：run() 方法执行完毕或异常终止

/**
 * 使用join方法实现线程顺序执行
 */
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执行：" + 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执行：" + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 启动线程A
        threadA.start();
        // 等待线程A执行完毕，再启动线程B
        threadA.join();
        threadB.start();
    }
}

public class UnsafeTicketDemo implements Runnable {
    private int ticketNum = 10;
    @Override
    public void run() {
        while (ticketNum > 0) {
            // 模拟网络延迟，放大并发问题
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 核心问题：判断和操作不是原子性的
            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 (锁对象) {
    // 需要同步的代码（操作共享资源的代码）
}

public class SafeTicketDemo1 implements Runnable {
    private int ticketNum = 10;
    // 定义锁对象：必须是多个线程共享的对象
    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 返回值类型 方法名(参数列表) {
    // 需要同步的代码
}

public class SafeTicketDemo2 implements Runnable {
    private int ticketNum = 10;
    @Override
    public void run() {
        while (true) {
            if (!sellTicket()) {
                break;
            }
        }
    }
    // 同步方法：锁定的是this对象
    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;
    // 创建可重入锁对象
    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,                  // 核心线程数
    int maximumPoolSize,               // 最大线程数
    long keepAliveTime,                // 非核心线程空闲存活时间
    TimeUnit unit,                     // 时间单位
    BlockingQueue<Runnable> workQueue, // 任务队列
    ThreadFactory threadFactory,       // 线程工厂
    RejectedExecutionHandler handler   // 拒绝策略
)

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 固定大小线程池的使用
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 1. 创建固定大小的线程池，核心线程数=最大线程数=3
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        // 2. 提交10个任务
        for (int i = 1; i <= 10; i++) {
            int taskId = i;
            executorService.submit(() -> {
                System.out.println("任务" + taskId + " 由线程 " + Thread.currentThread().getName() + " 执行");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        // 3. 关闭线程池
        executorService.shutdown();
    }
}

import java.util.concurrent.*;
/**
 * 手动创建线程池（推荐方式）
 */
public class CustomThreadPoolDemo {
    public static void main(String[] args) {
        // 1. 定义线程池参数
        int corePoolSize = 2;
        int maximumPoolSize = 5;
        long keepAliveTime = 60;
        TimeUnit unit = TimeUnit.SECONDS;
        // 任务队列：容量为3的阻塞队列
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(3);
        // 线程工厂：默认线程工厂
        ThreadFactory threadFactory = Executors.defaultThreadFactory();
        // 拒绝策略：丢弃任务并抛出异常
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
        // 2. 创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue,
                threadFactory,
                handler
        );
        // 3. 提交任务
        for (int i = 1; i <= 10; i++) {
            int taskId = i;
            try {
                executor.submit(() -> {
                    System.out.println("任务" + taskId + " 由线程 " + Thread.currentThread().getName() + " 执行");
                    Thread.sleep(1000);
                });
            } catch (Exception e) {
                System.out.println("任务" + taskId + " 被拒绝：" + e.getMessage());
            }
        }
        // 4. 关闭线程池
        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 {
    // 线程池：核心线程数2，最大线程数4
    private static final ExecutorService EXECUTOR = new ThreadPoolExecutor(
            2,
            4,
            60,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(2),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy()
    );
    // 下载状态列表
    private static final List<String> DOWNLOAD_STATUS = new ArrayList<>();
    /**
     * 下载单个文件
     * @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);
            // 读取文件流并写入本地
            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 {
            // 关闭资源
            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();
        }
        // 提交下载任务
        for (String url : urlList) {
            EXECUTOR.submit(() -> downloadFile(url, savePath));
        }
        // 关闭线程池
        EXECUTOR.shutdown();
        try {
            // 等待所有任务完成
            EXECUTOR.awaitTermination(1, TimeUnit.HOURS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 打印下载结果
        System.out.println("\n===== 下载完成 ======");
        for (String status : DOWNLOAD_STATUS) {
            System.out.println(status);
        }
    }
    public static void main(String[] args) {
        // 测试URL列表（替换为实际可下载的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盘download目录
        batchDownload(urlList, "D:\\download");
    }
}