Java 多线程编程：从基础原理到实战应用

输出结果（顺序不固定，体现线程并发执行）

线程 A 执行：1 线程 B 执行：1 线程 A 执行：2 线程 B 执行：2 线程 A 执行：3 线程 B 执行：3 线程 A 执行：4 线程 B 执行：4 线程 A 执行：5 线程 B 执行：5 

⚠️ 注意事项：启动线程必须调用 start() 方法，直接调用 run() 方法会变成普通方法的串行执行。

1.3.2 方式 2：实现 Runnable 接口

实现步骤

① 📝 定义一个类实现 Runnable 接口。 ② 📝 重写 run() 方法，编写线程执行逻辑。 ③ 📝 创建 Runnable 实现类对象，作为 Thread 构造方法的参数。 ④ 📝 调用 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();
    }
}

方式 2 的优势

1. 避免单继承的局限性：Java 是单继承机制，继承 Thread 类后无法再继承其他类，而实现 Runnable 接口可以。
2. 资源共享：多个线程可以共享同一个 Runnable 任务对象，适合多线程处理同一份资源的场景。

资源共享案例：多线程售票

/**
 * 多线程共享资源：模拟售票系统
 */
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();
    }
}

输出结果（存在线程安全问题，后面会解决）

窗口 1 售出第 10 张票 窗口 2 售出第 9 张票 窗口 3 售出第 8 张票 窗口 1 售出第 7 张票 窗口 2 售出第 6 张票 窗口 3 售出第 5 张票 窗口 1 售出第 4 张票 窗口 2 售出第 3 张票 窗口 3 售出第 2 张票 窗口 1 售出第 1 张票 

1.3.3 方式 3：实现 Callable 接口（带返回值）

实现步骤

① 📝 定义一个类实现 Callable<V> 接口，V 是返回值类型。 ② 📝 重写 call() 方法，编写线程执行逻辑，该方法可以抛出异常。 ③ 📝 创建 Callable 实现类对象，通过 FutureTask 包装。 ④ 📝 将 FutureTask 作为 Thread 构造方法参数，启动线程。 ⑤ 📝 调用 FutureTask 的 get() 方法获取返回值。

代码实操

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);
    }
}

输出结果

计算中：1，当前和为：1 计算中：2，当前和为：3 计算中：3，当前和为：6 计算中：4，当前和为：10 计算中：5，当前和为：15 计算中：6，当前和为：21 计算中：7，当前和为：28 计算中：8，当前和为：36 计算中：9，当前和为：45 计算中：10，当前和为：55 1 到 10 的累加和为：55 

✅ 核心结论：三种创建方式对比

1.4 线程的生命周期与状态转换

1.4.1 线程的六种状态

Java 中线程的生命周期包含六种状态，定义在 Thread.State 枚举中：

1. NEW（新建状态）：线程对象已创建，但未调用 start() 方法。
2. RUNNABLE（可运行状态）：调用 start() 方法后，线程处于就绪或运行中。
   • 就绪状态：线程等待 CPU 调度。
   • 运行状态：线程获取 CPU 资源，执行 run() 方法。
3. BLOCKED（阻塞状态）：线程等待获取锁资源时进入该状态。
4. WAITING（等待状态）：线程调用 wait()、join() 等方法后进入，需要被其他线程唤醒。
5. TIMED_WAITING（超时等待状态）：线程调用 sleep(long)、wait(long) 等方法后进入，超时自动唤醒。
6. TERMINATED（终止状态）：线程执行完毕或异常终止。

1.4.2 线程状态转换图（核心流程）

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() 方法执行完毕或异常终止

1.4.3 常用线程控制方法

代码实操：线程的顺序执行（join 方法）

/**
 * 使用 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();
    }
}

输出结果（线程 A 执行完才会执行线程 B）

线程 A 执行：1 线程 A 执行：2 线程 A 执行：3 线程 B 执行：1 线程 B 执行：2 线程 B 执行：3 

1.5 线程同步与并发安全

1.5.1 并发安全问题的产生

当多个线程同时操作共享资源时，会导致数据不一致的问题。比如前面的售票案例，在极端情况下会出现超卖或重复售票的问题。

问题复现：多线程售票的并发安全问题

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();
    }
}

可能出现的错误结果

窗口 1 售出第 10 张票 窗口 2 售出第 10 张票 窗口 3 售出第 9 张票 窗口 1 售出第 8 张票 窗口 2 售出第 7 张票 窗口 3 售出第 6 张票 窗口 1 售出第 5 张票 窗口 2 售出第 4 张票 窗口 3 售出第 3 张票 窗口 1 售出第 2 张票 窗口 2 售出第 1 张票 窗口 3 售出第 0 张票 

可以看到出现了重复售票和售出 0 号票的问题，这就是典型的并发安全问题。

1.5.2 解决方案 1：同步代码块（synchronized）

💡 同步代码块的核心是锁机制，通过 synchronized 关键字锁定一个对象，保证同一时间只有一个线程能执行代码块中的内容。

语法格式

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();
    }
}

输出结果（无重复、无超卖，解决并发安全问题）

窗口 1 售出第 10 张票 窗口 1 售出第 9 张票 窗口 2 售出第 8 张票 窗口 2 售出第 7 张票 窗口 3 售出第 6 张票 窗口 3 售出第 5 张票 窗口 1 售出第 4 张票 窗口 1 售出第 3 张票 窗口 2 售出第 2 张票 窗口 2 售出第 1 张票 

⚠️ 注意事项：锁对象必须是多个线程共享的对象，否则无法实现同步效果。

1.5.3 解决方案 2：同步方法（synchronized）

💡 同步方法是将 synchronized 关键字修饰在方法上，等价于锁定当前对象（this）。

语法格式

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();
    }
}

1.5.4 解决方案 3：Lock 锁（JUC 包）

💡 java.util.concurrent.locks.Lock 是 JDK 5 新增的锁机制，相比 synchronized 更加灵活，可以手动控制锁的获取和释放。 常用实现类是 ReentrantLock（可重入锁）。

实现步骤

① 📝 创建 ReentrantLock 对象。 ② 📝 在需要同步的代码前调用 lock() 方法获取锁。 ③ 📝 在 finally 块中调用 unlock() 方法释放锁，确保锁一定会被释放。

代码实操：Lock 锁解决售票问题

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();
    }
}

✅ 核心结论：synchronized 和 Lock 的对比

1.6 线程池：高效管理多线程

1.6.1 为什么需要线程池

频繁创建和销毁线程会消耗大量系统资源，线程池可以复用线程，降低系统开销。线程池的核心优势：

1. 降低资源消耗：复用已创建的线程，减少创建和销毁线程的开销。
2. 提高响应速度：任务到达时，无需等待线程创建即可立即执行。
3. 便于线程管理：可以控制最大并发数，避免线程过多导致资源耗尽。

1.6.2 线程池的核心参数（ThreadPoolExecutor）

Java 中线程池的核心实现类是 ThreadPoolExecutor，其构造方法包含 7 个核心参数：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    // ...
}

参数说明

1. 核心线程数：线程池长期保持的线程数量，即使空闲也不会销毁。
2. 最大线程数：线程池允许创建的最大线程数。
3. 空闲存活时间：非核心线程空闲超过该时间会被销毁。
4. 任务队列：存放等待执行的任务，当核心线程都在忙时，任务会进入队列。
5. 拒绝策略：当任务队列满且线程数达到最大时，如何处理新任务。

1.6.3 线程池的使用方式

方式 1：通过 Executors 工具类创建（快速使用）

Executors 提供了几种常用的线程池创建方法：

• newFixedThreadPool(int nThreads)：固定大小的线程池。
• newCachedThreadPool()：缓存线程池，线程数可动态调整。
• newSingleThreadExecutor()：单线程池，保证任务顺序执行。

代码实操：固定大小线程池

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();
    }
}

输出结果（3 个线程复用执行 10 个任务）

任务 1 由线程 pool-1-thread-1 执行 任务 2 由线程 pool-1-thread-2 执行 任务 3 由线程 pool-1-thread-3 执行 任务 4 由线程 pool-1-thread-1 执行 任务 5 由线程 pool-1-thread-2 执行 任务 6 由线程 pool-1-thread-3 执行 任务 7 由线程 pool-1-thread-1 执行 任务 8 由线程 pool-1-thread-2 执行 任务 9 由线程 pool-1-thread-3 执行 任务 10 由线程 pool-1-thread-1 执行 

方式 2：手动创建 ThreadPoolExecutor（推荐，更可控）

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();
    }
}

输出结果（当任务数超过 最大线程数 + 队列容量=8 时，新任务被拒绝）

任务 1 由线程 pool-1-thread-1 执行 任务 2 由线程 pool-1-thread-2 执行 任务 3 由线程 pool-1-thread-3 执行 任务 4 由线程 pool-1-thread-4 执行 任务 5 由线程 pool-1-thread-5 执行 任务 6 由线程 pool-1-thread-1 执行 任务 7 由线程 pool-1-thread-2 执行 任务 8 由线程 pool-1-thread-3 执行 任务 9 被拒绝：Task java.util.concurrent.FutureTask@6d311334 rejected from java.util.concurrent.ThreadPoolExecutor@682a0b20[Running, pool size = 5, active threads = 5, queued tasks = 3, completed tasks = 0] 任务 10 被拒绝：Task java.util.concurrent.FutureTask@3d075dc0 rejected from java.util.concurrent.ThreadPoolExecutor@682a0b20[Running, pool size = 5, active threads = 5, queued tasks = 3, completed tasks = 0] 

⚠️ 注意事项：实际开发中推荐手动创建线程池，避免使用 Executors 工具类的默认方法，防止资源耗尽。

1.7 实战案例：多线程实现文件批量下载

1.7.1 需求分析

💡 实现一个多线程文件下载工具，支持从指定 URL 列表批量下载文件，要求：

1. 使用线程池管理下载线程，控制并发数。
2. 记录每个文件的下载状态（成功/失败）。
3. 支持断点续传（可选）。

1.7.2 代码实现

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");
    }
}

1.7.3 案例总结

✅ 这个多线程下载工具综合运用了线程池、同步机制、IO 流等知识，核心亮点：

1. 使用线程池控制并发数，避免线程过多导致系统资源耗尽。
2. 使用 synchronized 保证下载状态列表的线程安全。
3. 采用 CallerRunsPolicy 拒绝策略，当任务过多时，由调用线程执行，避免任务丢失。
4. 完善的资源关闭和异常处理，保证程序健壮性。

1.8 本章总结

1. 线程是进程的执行单元，多线程可以提升程序并发效率，充分利用 CPU 资源。
2. 线程有三种创建方式：继承 Thread、实现 Runnable、实现 Callable，推荐使用后两种。
3. 线程的生命周期包含六种状态，核心是掌握状态之间的转换条件。
4. 并发安全问题的根源是多个线程操作共享资源，解决方案有 synchronized 同步代码块/方法、Lock 锁。
5. 线程池可以复用线程，降低系统开销，实际开发中推荐手动创建 ThreadPoolExecutor。
6. 多线程编程的核心是线程同步和资源管理，要注意避免死锁、内存可见性等问题。