目录
写在前面：
1、继承Thread类
特点:
类代码：
主程序代码:
2、实现Runnable接口
特点：
类代码：
主程序代码：
3、实现Callable接口
特点：
FutureTask常用方法
类代码：
主程序代码：
4、线程池
参数:
常用阻塞队列:
常用拒绝策略：
特点：
类代码：
主程序代码：
示例补充:
5、虚拟线程
特点：
创建虚拟线程：
创建虚拟线程池：
定时任务调度线程
（1）Timer，TimerTask
原理
有以下缺点:
(2)ScheduledThreadPoolExecutor
特点:
示例代码：
示例补充:
写在前面：
最近重新梳理了一下 Java 中创建线程的几种方式，从最基础的 Thread 类，到后来引入的线程池，再到比较新的虚拟线程，总结了一下他们各自的特点和使用示例，主要目的方便自己后面的快速查找复习。
1、继承Thread类
特点:
1、编程简单直观
直接在类中编写线程逻辑
适合简单的线程场景
2、受单继承限制，不利于资源共享，耦合度高，不适合线程池
类代码：
public class ThreadExtend extends Thread { @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println("线程执行：" + Thread.currentThread().getName()); } } }主程序代码:
public class main { public static void main(String[] args) { ThreadExtend thread1=new ThreadExtend(); thread1.start(); ThreadExtend thread2=new ThreadExtend(); thread2.start(); } } //结果 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-02、实现Runnable接口
特点：
1、避免单继承局限
Java 是单继承语言，实现 Runnable 后还可以继承其他类
更灵活，符合面向对象的设计原则
2、适合资源共享
多个线程可以共享同一个 Runnable 实例
适合多个线程处理同一资源的场景
3、便于线程池管理
线程池主要接受 Runnable/Callable 任务
更容易与现代并发工具集成
4、代码解耦
将任务逻辑与线程控制分离
更符合"组合优于继承"的设计原则
类代码：
//演示共享资源 public class ThreadRunnable implements Runnable{ private int nums=20; @Override public void run() { while(nums>0) { System.out.println("线程执行：" + Thread.currentThread().getName()); nums--; } } }主程序代码：
public class main { public static void main(String[] args) { ThreadRunnable threadRunnable = new ThreadRunnable(); Thread t1=new Thread(threadRunnable,"线程1"); Thread t2=new Thread(threadRunnable,"线程2"); Thread t3=new Thread(threadRunnable,"线程3"); t1.start(); t2.start(); t3.start(); } } //示例结果出现了线程安全问题，输出大于20个，可以在while循环内加锁 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程3 线程执行：线程2 线程执行：线程2 线程执行：线程2 线程执行：线程1 线程执行：线程33、实现Callable接口
特点：
1、
需要重写call()方法，有返回值，可以通过FutureTask获取状态。
FutureTask常用方法
（1）get()-阻塞获取结果
String result = futureTask.get(); // 一直等待直到任务完成（2）get(long timeout, TimeUnit unit) - 超时获取
// 最多等待5秒，超时抛 TimeoutException String result = futureTask.get(5, TimeUnit.SECONDS);（3）isDone() - 是否完成
boolean done = futureTask.isDone(); // true: 任务已完成（正常完成、异常或取消） // false: 任务还在执行中（4）isCancelled() - 是否被取消
boolean cancelled = futureTask.isCancelled(); // true: 任务在正常完成前被取消 // false: 任务未被取消（5）cancel(boolean mayInterruptIfRunning) - 取消任务
boolean cancelled = futureTask.cancel(false); // false: 不中断正在运行的任务，只阻止未开始的任务 // true: 尝试中断正在运行的任务 // 返回值： // true: 取消成功 // false: 取消失败（任务已完成或已被取消）cancel(false)在线程还在线程池排队没运行的时候能停下来
cancel(true)需要在run()代码中判断Thread.currentThread().isInterrupted(),检测线程是否收到中断信号来手动中断。或者执行sleep()等响应中断的阻塞方法也会使得任务退出。
（6）run() - 执行任务
futureTask.run(); // 通常在 Thread 中调用 // new Thread(futureTask).start(); 内部会调用这个方法Thread.start()调用第二次会直接报错抛出异常。
FutureTask.run()调用第二次不会报错但是会被静默忽略不会真正执行。
（7）runAndReset() - 执行并重置
boolean reset = futureTask.runAndReset(); // 用于可重复执行的任务，执行后重置状态这个方法可以重复执行，但是不能通过get得到结果。
2、
可以抛出异常。
类代码：
import java.util.concurrent.Callable; public class ThreadCallable implements Callable<String> { @Override public String call() throws Exception { for (int i = 0; i < 10; i++) { System.out.println("线程执行：" + Thread.currentThread().getName()); } return Thread.currentThread().getName()+"线程执行完毕"; } }主程序代码：
public static void main(String[] args) { FutureTask<String> futureTask1 = new FutureTask<>(new ThreadCallable()); Thread thread1 = new Thread(futureTask1); thread1.start(); FutureTask<String> futureTask2 = new FutureTask<>(new ThreadCallable()); Thread thread2 = new Thread(futureTask2); thread2.start(); try{ System.out.println(futureTask1.get()); } catch(Exception e){ e.printStackTrace(); } try{ System.out.println(futureTask2.get()); } catch(Exception e){ e.printStackTrace(); } } //结果 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-1 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 线程执行：Thread-0 Thread-0线程执行完毕 Thread-1线程执行完毕4、线程池
参数:
public ThreadPoolExecutor( int corePoolSize, // 1. 核心线程数 int maximumPoolSize, // 2. 最大线程数 long keepAliveTime, // 3. 空闲线程存活时间 TimeUnit unit, // 4. 时间单位 BlockingQueue<Runnable> workQueue, // 5. 任务阻塞队列 ThreadFactory threadFactory, // 6. 线程工厂 RejectedExecutionHandler handler // 7. 拒绝策略 )corePoolSize（核心线程数）：线程池中平时常驻的线程数量，即使空闲也不会被销毁。
maximumPoolSize（最大线程数）：线程池允许创建的最大线程数（核心线程 + 临时线程）。
keepAliveTime（空闲存活时间）：当线程数超过核心线程数时，多余的空闲线程在销毁前等待新任务的最长时间。
unit(时间单位),为keepAliveTime的时间单位
workQueue（任务队列）：当核心线程都在忙碌时，新提交的任务会被放入这个队列中等待。 threadFactory（线程工厂）：用于创建新线程，通常用来给线程设置有业务意义的名称，方便排查问题。
handler（拒绝策略）：当队列满了，且线程数达到了最大值时，对新任务的兜底处理策略（如直接抛出异常、让提交者自己执行等）。
常用阻塞队列:
ArrayBlockingQueue:
基于数组实现的有界阻塞队列，初始化时必须指定容量。它采用 FIFO（先进先出）原则，且内部使用一把全局锁来保证线程安全。
LinkedBlockingQueue
基于链表实现的阻塞队列。它既可以是有界的，也可以是无界的（如果初始化时不指定容量，默认容量为 Integer.MAX_VALUE）。它采用了读写分离的双锁机制，在高并发下吞吐量ArrayBlockingQueue 更高。注意无界时候容易栈溢出。
SynchronousQueue（零容量、手递手）
核心特点：一个不存储任何元素的特殊队列（容量为 0）。它的每次放入操作必须等待一个对应的取出操作
生产建议：通常会配合较大的 maximumPoolSize，因为没有排队缓冲，新任务来了必须立刻创建线程接手。
PriorityBlockingQueue
一个支持优先级的无界阻塞队列。任务不再是先进先出，而是根据自定义的比较器或自然顺序来决定执行顺序。
延迟队列：
使用 JDK 自带的ScheduledThreadPoolExecutor,内部配置了DelayedWorkQueue,这个队列和ThreadPoolExecutor不适配。
常用拒绝策略：
AbortPolicy（默认策略）
直接抛出一个 RejectedExecutionException 运行时异常，阻止任务提交。
CallerRunsPolicy（调用者运行策略）
不抛出异常，也不丢弃任务，而是将当前被拒绝的任务退回到提交该任务的线程（即调用者线程）中去执行。
适合允许延迟，任务不可丢失的的后台任务
原理：因为调用者线程需要亲自去执行被拒绝的任务，这会占用调用者的时间，从而自然地降低新任务提交的速度，让系统在高负载下实现平滑降级。
DiscardPolicy（丢弃策略）
静默地直接丢弃当前被拒绝的任务，不抛出任何异常，也不做任何通知。
DiscardOldestPolicy（丢弃最旧任务策略）
丢弃任务队列中等待时间最长（即队首）的那个任务，然后尝试重新提交当前这个最新的任务。
特点：
1、降低资源消耗,提高响应速度（线程复用）
传统方式：线程的创建和销毁是非常消耗系统资源的操作，需要频繁进行系统调用和上下文切换。
线程池：通过预先创建一批线程并长期存活，任务执行完毕后线程不会被销毁，而是归还到池中等待下一个任务。这种线程复用机制，极大地降低了频繁创建和销毁线程带来的 CPU 和内存开销。
2、增强系统的稳定性与可控性（避免资源耗尽）
传统方式：如果无限制地手动创建线程，会迅速耗尽系统的内存和 CPU 资源，极易导致系统卡顿甚至发生内存溢出崩溃。
线程池：可以对线程的最大并发数进行严格控制。当任务过多时，多余的任务会被放入队列等待，或者根据预设的拒绝策略进行处理，从而有效防止资源过载，保障系统的稳定性。
3、统一管理与功能丰富
传统方式：手动创建的线程分散且独立，开发者需要自己处理线程的生命周期、同步、优先级等，管理难度大且容易出错。
线程池：提供了统一的线程调度、生命周期管理、状态监控以及定时/周期性任务执行等高级功能，大大简化了并发编程的复杂度。
类代码：
import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class ThreadPoolUtil { public static ThreadPoolExecutor getThreadPoolExecutor() { return new ThreadPoolExecutor( 5, 10, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100), new ThreadPoolExecutor.DiscardOldestPolicy() ); } } //上述代码每次都会返回一个新的线程池，只是示例有很多隐患，下方用单例实现。 public class ThreadPoolUtil { // 使用 private static final 确保线程池全局唯一且不可变 private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor( 5, 10, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100), new ThreadPoolExecutor.DiscardOldestPolicy() ); // 提供全局访问点，直接返回已创建好的实例 public static ThreadPoolExecutor getThreadPoolExecutor() { return threadPool; } }主程序代码：
import java.util.concurrent.FutureTask; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class main { public static void main(String[] args) { ThreadPoolExecutor executor = ThreadPoolUtil.getThreadPoolExecutor(); try{ for(int i=1;i<=20;i++) { int taskId=i; executor.execute(()->{ System.out.println("任务"+taskId+"正在被"+Thread.currentThread().getName()+"执行"); try{ Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } }); } } catch (Exception e) { e.printStackTrace(); } finally{ executor.shutdown();//不再接受新的任务，线程池会等待所有任务执行完毕，再关闭 try { if(!executor.awaitTermination(60, TimeUnit.SECONDS)){//阻塞等待60秒线程池所有任务还没有完成返回false executor.shutdownNow(); } } catch (InterruptedException e) { throw new RuntimeException(e); } } } } //运行结果 任务3正在被pool-1-thread-4执行 任务4正在被pool-1-thread-5执行 任务2正在被pool-1-thread-3执行 任务1正在被pool-1-thread-2执行 任务0正在被pool-1-thread-1执行 任务5正在被pool-1-thread-4执行 任务6正在被pool-1-thread-5执行 任务7正在被pool-1-thread-2执行 任务9正在被pool-1-thread-1执行 任务8正在被pool-1-thread-3执行 任务10正在被pool-1-thread-1执行 任务11正在被pool-1-thread-3执行 任务12正在被pool-1-thread-2执行 任务13正在被pool-1-thread-5执行 任务14正在被pool-1-thread-4执行 任务15正在被pool-1-thread-1执行 任务16正在被pool-1-thread-3执行 任务17正在被pool-1-thread-4执行 任务18正在被pool-1-thread-5执行 任务19正在被pool-1-thread-2执行示例补充:
示例代码中核心线程数为5个，因为20个任务并没有超过核心线程数+队列数，所以不会启动扩容创建新线程，因为线程运行中睡眠一秒，能看到输出情况是每一秒输出五个。
5、虚拟线程
特点：
1、资源消耗：极致的轻量
传统线程：每个线程都有一个固定的、较大的栈内存（默认 1MB 左右），且由操作系统管理。如果你尝试创建几十万个传统线程，系统内存会瞬间耗尽。
虚拟线程：
它的栈空间不是连续分配的，而是按需动态伸缩的（初始只有几 KB）。你可以轻松在一台普通电脑上创建数百万个虚拟线程，而不会导致内存溢出。
2、虚拟现场被设置为强制后台线程，哪怕继承了主线程，JVM也不会等待。
3、应用场景：
适合：高吞吐量的 Web 服务、微服务调用、数据库访问。
不适合：CPU 密集型任务（如复杂的数学计算、图像处理）。
原因：虚拟线程的优势在于 I/O 阻塞时的切换。如果是纯计算任务，它不会阻塞，会一直占用载体线程，此时它就退化成了普通线程，且因为调度层多了一层，反而可能略慢。对于 CPU 密集型任务，还是应该使用传统的线程池。
创建虚拟线程：
Thread.Builder builder = Thread.ofVirtual().name("worker-", 0); for (int i = 0; i < 3; i++) { int taskId = i; builder.start(() -> { System.out.println("[线程3] 任务 " + taskId + " 在 " + Thread.currentThread().getName() + " 中执行"); }); } // 主线程等待1秒，让虚拟线程有时间执行 Thread.sleep(1000); //结果 [线程3] 任务 2 在 worker-2 中执行 [线程3] 任务 0 在 worker-0 中执行 [线程3] 任务 1 在 worker-1 中执行 //或者更简单的方法 //使用 Thread.startVirtualThread() Thread vThread1 = Thread.startVirtualThread(() -> { System.out.println("[线程1] 虚拟线程名称: " + Thread.currentThread().getName()); System.out.println("[线程1] 是否是虚拟线程: " + Thread.currentThread().isVirtual()); }); vThread1.join();创建虚拟线程池：
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) { // 提交多个任务 for (int i = 1; i <= 5; i++) { int taskId = i; executor.submit(() -> { System.out.println("[线程池] 任务 " + taskId + " 开始执行 - " + Thread.currentThread().getName()); // 模拟 I/O 操作 try { Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } System.out.println("[线程池] 任务 " + taskId + " 完成执行"); return "结果-" + taskId; }); } // 等待所有任务完成 executor.shutdown(); executor.awaitTermination(10, TimeUnit.SECONDS); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } System.out.println("[线程池] 所有任务已完成\n"); //结果 [线程池] 任务 3 开始执行 - [线程池] 任务 2 开始执行 - [线程池] 任务 5 开始执行 - [线程池] 任务 1 开始执行 - [线程池] 任务 4 开始执行 - [线程池] 任务 1 完成执行 [线程池] 任务 5 完成执行 [线程池] 任务 4 完成执行 [线程池] 任务 3 完成执行 [线程池] 任务 2 完成执行 [线程池] 所有任务已完成定时任务调度线程
（1）Timer，TimerTask
原理
使用 Timer 和 TimerTask 创建线程，并不是一种完全独立、全新的底层创建线程的方法。它本质上是基于 Java 最基础的实现 Runnable 接口这一方式，并在此基础上进行了更高层次的封装，专门用于实现定时或周期性任务。
有以下缺点:
单线程隐患：一个 Timer 只有一个工作线程。如果其中一个 TimerTask 执行时间过长，会延迟其他所有任务的执行；更严重的是，如果某个任务抛出了未捕获的异常，整个 Timer 的工作线程就会直接挂掉，导致后续所有任务都无法再执行。
依赖系统时间：Timer 是基于系统的绝对时间来调度的，如果操作系统的系统时间被修改，定时任务的执行就会变得不准确。
所以现在不常用。
(2)ScheduledThreadPoolExecutor
特点:
1. 继承自 ThreadPoolExecutor，这意味着它天然拥有了标准线程池的所有基础能力，比如线程的复用、并发控制、线程生命周期管理等。
2、核心任务队列：DelayedWorkQueue
底层结构：这是一个基于最小堆（Min-Heap）数据结构实现的优先级队列。
核心作用：它会把所有提交的任务，按照“距离执行时间”的长短进行排序。距离下次执行时间最近的任务，永远会排在队列的最前面（堆顶）。工作线程每次只需要盯着堆顶的任务，如果时间没到就继续等待，从而实现了精准的定时调度。
3、核心任务封装：ScheduledFutureTask
当你提交一个定时任务时，ScheduledThreadPoolExecutor 不会直接把你的任务扔进队列，而是会先把它包装成一个 ScheduledFutureTask 对象。
核心作用：这个包装类里不仅包含了你的业务逻辑，还额外记录了任务的触发时间和周期。
周期性原理：对于周期性任务，这个包装类在执行完一次任务后，会自动计算出下一次应该执行的时间，然后把自己重新塞回 DelayedWorkQueue 中排队。这就形成了一个“执行 -> 计算下次时间 -> 重新入队 -> 等待执行”的完美闭环。
示例代码：
// 创建定时任务线程池 ScheduledThreadPoolExecutor scheduler = new ScheduledThreadPoolExecutor(3); System.out.println("程序启动时间：" + System.currentTimeMillis()); // 1. 延迟5秒执行一次 scheduler.schedule(() -> { System.out.println("[延迟任务] 执行时间：" + System.currentTimeMillis()); }, 5, TimeUnit.SECONDS); // 2. 固定频率执行：初始延迟2秒，每3秒执行一次 scheduler.scheduleAtFixedRate(() -> { System.out.println("[固定频率] 执行时间：" + System.currentTimeMillis()); }, 2, 3, TimeUnit.SECONDS); // 3. 固定延迟执行：初始延迟1秒，每次执行完延迟2秒 scheduler.scheduleWithFixedDelay(() -> { System.out.println("[固定延迟] 执行时间：" + System.currentTimeMillis()); try { Thread.sleep(500); // 模拟任务执行 } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, 1, 2, TimeUnit.SECONDS); // 主线程等待15秒后关闭线程池 try { Thread.sleep(15000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } // 关闭线程池 scheduler.shutdown();示例补充:
scheduleWithFixedDelay：保证任务之间有固定的"休息时间"，适合需要控制执行频率、避免系统过载的场景
scheduleAtFixedRate：保证任务按固定时间点执行，适合对时间精度要求高的场景
在使用scheduleAtFixedRate的时候如果执行时间大于设置周期，任务会一个接一个立即执行，没有等待时间,长时间下去会导致任务堆积，内存溢出，线程饥饿等问题。
--------------------------------------------------------------------------------------------------------------------
到这里就结束喽✿✿✿✿✿✿
