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

Ne0inhk

— 20 min read
JAVA 多线程编程：从基础原理到实战应用

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

在这里插入图片描述

1.1 本章学习目标与重点

💡 掌握线程的核心概念，理解进程与线程的区别和联系。
💡 熟练掌握线程的三种创建方式，理解线程的生命周期及状态转换。
💡 掌握线程同步与锁机制，解决多线程并发安全问题。
💡 了解线程池的核心原理与使用方法，提升多线程程序性能。
⚠️ 本章重点是 线程同步机制 和 线程池的实战应用，这是多线程开发中的核心难点和高频考点。

1.2 多线程核心概念

1.2.1 进程与线程的区别

💡 进程是操作系统进行资源分配和调度的基本单位，每个进程都有独立的内存空间和系统资源。比如打开一个 Java 程序，就会启动一个进程。
💡 线程是进程的执行单元，是 CPU 调度和执行的基本单位。一个进程可以包含多个线程，这些线程共享进程的内存空间和资源。

对比维度进程线程
资源分配拥有独立的内存空间和资源共享所属进程的内存和资源
开销成本创建和销毁开销大创建和销毁开销小
调度方式由操作系统内核调度由进程内部调度
独立性进程之间相互独立线程之间共享资源，依赖性强

✅ 核心结论：线程是轻量级的进程，多线程编程可以充分利用 CPU 资源，提升程序的并发执行效率。

1.2.2 为什么需要多线程

在单线程程序中，代码是串行执行的，当遇到耗时操作（如文件读写、网络请求）时，程序会阻塞等待，造成 CPU 资源浪费。
多线程的优势体现在以下场景：

  1. 后台任务处理：如电商系统的订单超时取消、数据同步等。
  2. 异步操作：如用户注册后发送短信验证码，不阻塞主流程。
  3. 提高 CPU 利用率：如计算密集型任务，多线程可以充分利用多核 CPU。

1.3 线程的创建方式

1.3.1 方式1：继承 Thread 类

实现步骤

① 📝 定义一个类继承 Thread 类。
② 📝 重写 run() 方法，编写线程执行的业务逻辑。
③ 📝 创建线程对象，调用 start() 方法启动线程。

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

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

线程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接口创建线程 */publicclassMyRunnableimplementsRunnable{privateString taskName;publicMyRunnable(String taskName){this.taskName = taskName;}@Overridepublicvoidrun(){for(int i =1; i <=5; i++){System.out.println(taskName +" 执行："+ i);try{Thread.sleep(500);}catch(InterruptedException e){ e.printStackTrace();}}}publicstaticvoidmain(String[] args){// 创建任务对象MyRunnable task1 =newMyRunnable("任务A");MyRunnable task2 =newMyRunnable("任务B");// 创建线程对象，传入任务Thread thread1 =newThread(task1);Thread thread2 =newThread(task2);// 启动线程 thread1.start(); thread2.start();}}
方式2的优势
  1. 避免单继承的局限性：Java 是单继承机制，继承 Thread 类后无法再继承其他类，而实现 Runnable 接口可以。
  2. 资源共享：多个线程可以共享同一个 Runnable 任务对象，适合多线程处理同一份资源的场景。
资源共享案例：多线程售票
/** * 多线程共享资源：模拟售票系统 */publicclassTicketRunnableimplementsRunnable{// 共享资源：10张票privateint ticketNum =10;@Overridepublicvoidrun(){while(ticketNum >0){// 模拟售票耗时try{Thread.sleep(300);}catch(InterruptedException e){ e.printStackTrace();}System.out.println(Thread.currentThread().getName()+" 售出第 "+ ticketNum--+" 张票");}}publicstaticvoidmain(String[] args){// 一个任务对象，多个线程共享TicketRunnable ticketTask =newTicketRunnable();// 三个线程模拟三个售票窗口Thread window1 =newThread(ticketTask,"窗口1");Thread window2 =newThread(ticketTask,"窗口2");Thread window3 =newThread(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() 方法获取返回值。

代码实操
importjava.util.concurrent.Callable;importjava.util.concurrent.FutureTask;/** * 实现Callable接口创建线程（带返回值） */publicclassMyCallableimplementsCallable<Integer>{// 计算1到n的累加和privateint n;publicMyCallable(int n){this.n = n;}@OverridepublicIntegercall()throwsException{int sum =0;for(int i =1; i <= n; i++){ sum += i;System.out.println("计算中："+ i +"，当前和为："+ sum);Thread.sleep(200);}return sum;}publicstaticvoidmain(String[] args)throwsException{// 创建Callable任务MyCallable callableTask =newMyCallable(10);// 用FutureTask包装，用于获取返回值FutureTask<Integer> futureTask =newFutureTask<>(callableTask);// 创建线程并启动Thread thread =newThread(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

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

创建方式优点缺点
继承 Thread编程简单，直接使用 this 获取线程单继承局限，无法共享资源
实现 Runnable避免单继承，支持资源共享无返回值，无法抛出受检异常
实现 Callable有返回值，支持异常抛出编程相对复杂

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 常用线程控制方法

方法作用注意事项
start()启动线程一个线程只能调用一次
sleep(long millis)让线程休眠指定时间不会释放持有的锁资源
wait()让线程进入等待状态必须在同步代码块中调用，会释放锁
notify()唤醒一个等待的线程必须在同步代码块中调用
notifyAll()唤醒所有等待的线程必须在同步代码块中调用
join()等待该线程执行完毕可以实现线程的顺序执行
代码实操：线程的顺序执行（join 方法）
/** * 使用join方法实现线程顺序执行 */publicclassThreadJoinDemo{publicstaticvoidmain(String[] args)throwsInterruptedException{Thread threadA =newThread(()->{for(int i =1; i <=3; i++){System.out.println("线程A执行："+ i);try{Thread.sleep(500);}catch(InterruptedException e){ e.printStackTrace();}}});Thread threadB =newThread(()->{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 并发安全问题的产生

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

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

publicclassUnsafeTicketDemoimplementsRunnable{privateint ticketNum =10;@Overridepublicvoidrun(){while(ticketNum >0){// 模拟网络延迟，放大并发问题try{Thread.sleep(100);}catch(InterruptedException e){ e.printStackTrace();}// 核心问题：判断和操作不是原子性的System.out.println(Thread.currentThread().getName()+" 售出第 "+ ticketNum--+" 张票");}}publicstaticvoidmain(String[] args){UnsafeTicketDemo task =newUnsafeTicketDemo();newThread(task,"窗口1").start();newThread(task,"窗口2").start();newThread(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(锁对象){// 需要同步的代码（操作共享资源的代码）}
代码实操：同步代码块解决售票问题
publicclassSafeTicketDemo1implementsRunnable{privateint ticketNum =10;// 定义锁对象：必须是多个线程共享的对象privatefinalObject lock =newObject();@Overridepublicvoidrun(){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;}}}}publicstaticvoidmain(String[] args){SafeTicketDemo1 task =newSafeTicketDemo1();newThread(task,"窗口1").start();newThread(task,"窗口2").start();newThread(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）。

语法格式
publicsynchronized 返回值类型 方法名(参数列表){// 需要同步的代码}
代码实操：同步方法解决售票问题
publicclassSafeTicketDemo2implementsRunnable{privateint ticketNum =10;@Overridepublicvoidrun(){while(true){if(!sellTicket()){break;}}}// 同步方法：锁定的是this对象privatesynchronizedbooleansellTicket(){if(ticketNum >0){try{Thread.sleep(100);}catch(InterruptedException e){ e.printStackTrace();}System.out.println(Thread.currentThread().getName()+" 售出第 "+ ticketNum--+" 张票");returntrue;}else{returnfalse;}}publicstaticvoidmain(String[] args){SafeTicketDemo2 task =newSafeTicketDemo2();newThread(task,"窗口1").start();newThread(task,"窗口2").start();newThread(task,"窗口3").start();}}

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

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

实现步骤

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

代码实操：Lock 锁解决售票问题
importjava.util.concurrent.locks.ReentrantLock;publicclassSafeTicketDemo3implementsRunnable{privateint ticketNum =10;// 创建可重入锁对象privatefinalReentrantLock lock =newReentrantLock();@Overridepublicvoidrun(){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();}}}publicstaticvoidmain(String[] args){SafeTicketDemo3 task =newSafeTicketDemo3();newThread(task,"窗口1").start();newThread(task,"窗口2").start();newThread(task,"窗口3").start();}}

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

特性synchronizedLock
锁获取释放自动获取和释放手动调用 lock()/unlock()
灵活性低高（支持公平锁/非公平锁）
可中断性不支持支持
条件变量不支持支持（Condition）

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

1.6.1 为什么需要线程池

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

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

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

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

publicThreadPoolExecutor(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()：单线程池，保证任务顺序执行。
代码实操：固定大小线程池
importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;/** * 固定大小线程池的使用 */publicclassThreadPoolDemo{publicstaticvoidmain(String[] args){// 1. 创建固定大小的线程池，核心线程数=最大线程数=3ExecutorService 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（推荐，更可控）
importjava.util.concurrent.*;/** * 手动创建线程池（推荐方式） */publicclassCustomThreadPoolDemo{publicstaticvoidmain(String[] args){// 1. 定义线程池参数int corePoolSize =2;int maximumPoolSize =5;long keepAliveTime =60;TimeUnit unit =TimeUnit.SECONDS;// 任务队列：容量为3的阻塞队列BlockingQueue<Runnable> workQueue =newArrayBlockingQueue<>(3);// 线程工厂：默认线程工厂ThreadFactory threadFactory =Executors.defaultThreadFactory();// 拒绝策略：丢弃任务并抛出异常RejectedExecutionHandler handler =newThreadPoolExecutor.AbortPolicy();// 2. 创建线程池ThreadPoolExecutor executor =newThreadPoolExecutor( 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 代码实现

importjava.io.*;importjava.net.HttpURLConnection;importjava.net.URL;importjava.util.ArrayList;importjava.util.List;importjava.util.concurrent.*;/** * 多线程文件批量下载工具 */publicclassMultiThreadFileDownloader{// 线程池：核心线程数2，最大线程数4privatestaticfinalExecutorServiceEXECUTOR=newThreadPoolExecutor(2,4,60,TimeUnit.SECONDS,newArrayBlockingQueue<>(2),Executors.defaultThreadFactory(),newThreadPoolExecutor.CallerRunsPolicy());// 下载状态列表privatestaticfinalList<String>DOWNLOAD_STATUS=newArrayList<>();/** * 下载单个文件 * @param fileUrl 文件URL * @param savePath 保存路径 */privatestaticvoiddownloadFile(String fileUrl,String savePath){HttpURLConnection connection =null;InputStream in =null;OutputStream out =null;try{URL url =newURL(fileUrl); connection =(HttpURLConnection) url.openConnection(); connection.setConnectTimeout(5000); connection.setReadTimeout(5000);// 获取文件名String fileName = fileUrl.substring(fileUrl.lastIndexOf("/")+1);File saveFile =newFile(savePath +File.separator + fileName);// 读取文件流并写入本地 in = connection.getInputStream(); out =newFileOutputStream(saveFile);byte[] buffer =newbyte[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 保存路径 */publicstaticvoidbatchDownload(List<String> urlList,String savePath){// 检查保存路径是否存在File saveDir =newFile(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);}}publicstaticvoidmain(String[] args){// 测试URL列表（替换为实际可下载的URL）List<String> urlList =newArrayList<>(); 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. 多线程编程的核心是线程同步和资源管理，要注意避免死锁、内存可见性等问题。

Read more

Re：从零开始的 C++ 入門篇（五）类和对象·第二篇：构造函数与析构函数

Re：从零开始的 C++ 入門篇（五）类和对象·第二篇：构造函数与析构函数

◆ 博主名称： 晓此方-ZEEKLOG博客 大家好，欢迎来到晓此方的博客。 ⭐️C++系列个人专栏： 此方带你玩转C++_晓此方的博客-ZEEKLOG博客  ⭐️踏破千山志未空，拨开云雾见晴虹。 人生何必叹萧瑟，心在凌霄第一峰 0.1概述&前言         从本文会开始，此方会为大家带来类的默认成员函数的内容。该方面是C/C++类和对象篇章最难以理解的部分，构造函数和析构函数分别取代了C语言的Init函数和destory函数，大大提升了运行效率。默认成员函数的学习将为后续内容打下深厚的基础，本文讲解深入骨髓，细节无微不至，希望看完后能让你对这两者有深入的认识。 一，类的默认成员函数 定义：      默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数。 一个类，我们不写的情况下编译器会默认生成以下6个默认成员函数：        需要注意的是这6个中最重要的是前4个。最后两个取地址重载不重要，我们稍微了解一下即可。其次就是C++11以后还会增加两个默认成员函数，移动构造和移动赋值，这个我们后面再讲解。默认成员函数很重要，也比较复杂

By Ne0inhk
C++:set/multiset和map/multimap文档详细解析

C++:set/multiset和map/multimap文档详细解析

Hello大家好！ 很高兴与大家见面！ 给生活添点快乐，开始今天的编程之路。 我的博客:<但愿. 我的专栏:C语言、题目精讲、算法与数据结构、C++ 欢迎点赞，关注 目录   前言   一 容器的分类(根据容器中各个数据之间的关系）          1.1序列式容器                  1.1.1序列式容器的概念                  1.1.2序列式容器的例子           1.2关联式容器                  1.2.1关联式容器的概念                  1.2.2关联式容器的例子   二  set/multiset           2.1参考文档(multiset包在set中所以其没有头文件）           2.2set类的介绍                   2.2.1set类的实现的简单介绍                  2.2.2set类的接口介绍                           2.

By Ne0inhk
C++/数据结构：哈希表知识点

C++/数据结构：哈希表知识点

目录 哈希表 理解哈希表 哈希值（整形） BKDR哈希   异或组合  hash_combine 哈希函数 直接定址法 除留余数法 平方取中法 基数转换法 哈希冲突 开放定址法 哈希桶 unordered_map和unorder_set如何共用一个哈希桶模板类 stl的哈希桶中Insert如何得到的键值 键为自定义类型的处理         前言：本篇文章前半部分内容为哈希表的原理， 从上到下按照理解链逐层递进。 最后三个小标题占了比较大的篇幅， 是结合c++代码来叙述， 主要内容为stl中的哈希桶如何封装的。 如果有错误的地方， 欢迎友友们指正哦。         ps:本篇文章一直到哈希桶，除了最后三个小标题，c++和java的同学都可以看， 讲的是数据结构， 即便有c++代码也很简单哦。 哈希表         首先要理解哈希和哈希表有什么不同。 哈希就是映射， 是一种算法思想。 哈希表就是映射表， 是利用映射这种思想写出的一种数据结构。          所有的哈希表的算法流程都是类似的——拿到一个key， 利用哈希函数进行hash

By Ne0inhk
C++之基于正倒排索引的Boost搜索引擎项目数据清洗代码及详解（上）

C++之基于正倒排索引的Boost搜索引擎项目数据清洗代码及详解（上）

1.为什么要进行数据清洗 这是因为我们获得的网页信息包含了很多我们不想要的部分（标签），同时我们需要把title还有content从网页里面提取出来，这样方便我们后期对其进行处理。 2. 怎么进行数据清洗 我们可以把这分为三步。 2.1 第一步 第一步就是通过Enumfile函数把src_path里面的文件名（带路径），保存到file_list中，方便后期对文件进行一个一个的读取。 PS:src_path里面存的就是没有被处理过的信息。 这一步的本质是把src_path里面的关于网页的部分先筛选出来，我们只需要以.html结尾的普通网页文件，其他的都不要。 2.2 第二步 把筛选后的文件去标签化，然后把其分为title和content并构建url，接着存入results里面。 PS:之所以要去标签是因为网页里面实际上包含了很多很多没有的部分，可能是文字的大小或者颜色之类的。我们要把这些全部都去除。 就是把这里打钩的全部提取出来。 2.3 第三步 把去标签后的信息全部给写入到output里面。 PS:我们看到这里可能会疑惑为什么不写到一起，为什么要一步就要换

By Ne0inhk