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

Flutter for OpenHarmony: Flutter 三方库 hashlib 为鸿蒙应用提供军用级加密哈希算法支持（安全数据完整性卫士）

Flutter for OpenHarmony: Flutter 三方库 hashlib 为鸿蒙应用提供军用级加密哈希算法支持（安全数据完整性卫士）

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.ZEEKLOG.net 前言 在 OpenHarmony 应用开发中，涉及到本地存储加密、用户密码脱敏、大文件完整性校验或区块链应用时，一套算法完备、执行高效的哈希（Hash）库是必不可少的。虽然 Dart 原生也提供了一些简单的加密方法，但在算法多样性（如 Argon2、SHA-3, Blake2b 等高级算法）和性能表现方面，往往无法满足高安全等级项目的需求。 hashlib 正是专门为高性能数据加解密与完整性校验打造的库。它纯代码实现且经过了极致的循环优化，是鸿蒙平台上保护敏感数据的数字堡垒。 一、核心加密算法矩阵 hashlib 支持极其广泛且先进的加密标准。 原始明文数据 hashlib 算法引擎 传统算法 (MD5 / SHA-256) 现代算法 (SHA-3 / Keccak) 极致速度 (Blake2b / Blake2s) 密钥派生 (Argon2 / Scrypt)

By Ne0inhk
libmd 实现详解：仓颉语言中的哈希算法库开发实践

libmd 实现详解：仓颉语言中的哈希算法库开发实践

libmd 实现详解：仓颉语言中的哈希算法库开发实践 前言 密码学哈希函数是现代信息安全的基石，广泛应用于数据完整性验证、数字签名、用户认证和数据安全存储等领域。在仓颉语言生态中，libmd库提供了完整的密码哈希算法实现，支持多种主流哈希算法，包括经典的MD2、MD4、MD5，以及SHA系列（SHA-1、SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/256）和RIPEMD-160等算法。同时，该库还提供了HMAC功能，支持消息认证码的生成，为数据提供了额外的安全保障。 本文将从库的设计思路、核心实现、技术挑战、性能优化等多个维度，深入解析libmd库的开发过程，为仓颉语言开发者提供库开发的实践参考。 一、库概述 1.1 项目背景 在软件开发的众多领域，数据完整性验证和安全性保障是至关重要的需求。哈希算法因其单向性、抗碰撞性和雪崩效应等特性，成为解决这些问题的理想工具。从文件校验到用户认证，从区块链技术到数字签名，哈希算法的应用无处不在。 libmd库旨在为仓颉语言提供一套完整、高效、易用的哈希算法解决方案，支持多种主流哈希算法，

By Ne0inhk
算法基础篇：（二十一）数据结构之单调栈：从原理到实战，玩转高效解题

算法基础篇：（二十一）数据结构之单调栈：从原理到实战，玩转高效解题

目录 前言 一、什么是单调栈？先打破 “栈” 的常规认知 1.1 单调栈的核心特性 1.2 如何实现一个单调栈？ 实现单调递增栈 实现单调递减栈 1.3 核心操作解析：为什么要 “弹出元素”？ 二、单调栈能解决什么问题？四大核心场景全覆盖 2.1 场景 1：找左侧最近的 “更大元素” 问题描述 解题思路 代码实现 测试用例验证 2.2 场景 2：找左侧最近的 “更小元素” 问题描述 解题思路 代码实现 测试用例验证 2.3 场景 3：找右侧最近的 “更大元素” 问题描述

By Ne0inhk
直流无刷电机FOC控制算法

直流无刷电机FOC控制算法

文章目录 * 1、FOC概述 * 1.1 FOC控制算法介绍 * 2、无刷电机 * 2.1 无刷电机介绍 * 2.2 无刷电机和永磁同步电机的区别 * 2.3 无刷电机的控制原理 * 2.3.1 无刷电机工作原理 * 2.3.2 直流无刷电机驱动原理 * 2.3.2.1 有感直流无刷电机六步换相驱动原理 * 2.3.2.2 直流无刷电机FOC控制原理 * 3、无刷电机FOC控制算法 * 3.1 FOC控制算法整体流程 * 3.2 FOC算法Clarke变换 * 3.2.1 Clarke变换公式推导 * 3.2.2

By Ne0inhk