目录
（2）使用 ThreadPoolExecutor 直接创建线程池：
（2）shutdown() 和 shutdownNow()：
Java多线程编程是并发编程的一部分，旨在通过并行执行任务提高程序的执行效率。Java提供了强大的多线程支持，包括 Thread 类和 Runnable 接口以及更高级的 Executor 服务、同步工具（如 synchronized、Lock）、条件变量等。
前言：
在计算机中，我们把一个任务称为一个进程，浏览器就是一个进程，视频播放器是另一个进程，类似的，音乐播放器和Word都是进程。
某些进程内部还需要同时执行多个子任务。例如，我们在使用Word时，Word可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行打印，我们把子任务称为线程。
进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个线程。
操作系统调度的最小任务单位其实不是进程，而是线程。常用的Windows、Linux等操作系统都采用抢占式多任务，如何调度线程完全由操作系统决定，程序自己不能决定什么时候执行，以及执行多长时间。
Java语言内置了多线程支持：一个Java程序实际上是一个JVM进程，JVM进程用一个主线程来执行main()方法，在main()方法内部，我们又可以启动多个线程。此外，JVM还有负责垃圾回收的其他工作线程等。
因此，对于大多数Java程序来说，我们说多任务，实际上是说如何使用多线程实现多任务。
和单线程相比，多线程编程的特点在于：多线程经常需要读写共享数据，并且需要同步。例如，播放电影时，就必须由一个线程播放视频，另一个线程播放音频，两个线程需要协调运行，否则画面和声音就不同步。因此，多线程编程的复杂度高，调试更困难。
Java多线程编程的特点又在于：
- 多线程模型是Java程序最基本的并发模型；
- 后续读写网络、数据库、Web开发等都依赖Java多线程模型。
因此，必须掌握Java多线程编程才能继续深入学习其他内容。
一.线程的创建：
1.通过继承 Thread 类来创建线程：
Java中可以通过继承 Thread 类来创建线程。在 Thread 类中重写 run() 方法，实现线程的执行逻辑。
// 继承 Thread 类创建线程
class MyThread extends Thread {
@Override
public void run() {
// 线程执行的任务
System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行");
}
}
public class ThreadDemo {
public static void main(String[] args) {
// 创建线程对象
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
// 启动线程
thread1.start();
thread2.start();
}
}
Thread类提供了一个run()方法，继承Thread类并重写run()方法，可以定义线程要执行的任务。start()方法会启动线程并调用run()方法。start()方法会把线程放入线程调度队列，等待CPU分配时间片。
2.通过Runnable接口创建线程：
Runnable 接口是Java提供的一个函数式接口，定义了一个 run() 方法。线程可以通过实现 Runnable 接口来创建。
// 实现 Runnable 接口创建线程
class MyRunnable implements Runnable {
@Override
public void run() {
// 线程执行的任务
System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行");
}
}
public class RunnableDemo {
public static void main(String[] args) {
// 创建 Runnable 对象
MyRunnable runnable = new MyRunnable();
// 创建 Thread 对象，并传入 Runnable
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
// 启动线程
thread1.start();
thread2.start();
}
}
Runnable接口只有一个run()方法，因此它比继承Thread类更具灵活性，可以让一个任务实现多个线程。Thread的构造方法可以传入一个实现了Runnable接口的对象，通过start()启动线程。
3.通过Java8引入的lambda语法：
// 多线程
public class ThreadDemo1 {
public static void main(String[] args) {
Thread t = new Thread(() -> {
System.out.println("start new thread!");
});
t.start(); // 启动新线程
}
}线程的优先级：
我们可以对线程设定优先级，设定优先级的方法是：
Thread.setPriority(int n) // 1~10, 默认值5JVM自动把1（低）~10（高）的优先级映射到操作系统实际优先级上（不同操作系统有不同的优先级数量）。优先级高的线程被操作系统调度的优先级较高，操作系统对高优先级线程可能调度更频繁，但我们决不能通过设置优先级来确保高优先级的线程一定会先执行。
二.线程的生命周期：
在Java程序中，一个线程对象只能调用一次 start()方法启动新线程，并在新线程中执行 run()方法。一旦 run()方法执行完毕，线程就结束了。
因此Java中的线程有多个状态，常见的状态有：
- New：线程被创建但尚未启动。
- Runnable：线程在就绪队列中，等待 CPU 调度。
- Blocked：线程正在等待获取锁，进入阻塞状态。
- Waiting：线程调用
wait()、join()等方法进入等待状态，直到其他线程通知。- Timed Waiting：线程在指定时间内处于等待状态，超时后会被唤醒。
- Terminated：线程执行结束或由于异常终止。
当线程启动后，它可以在Runnable、Blocked、Waiting和Timed Waiting这几个状态之间切换，直到最后变成Terminated状态，线程终止。
线程终止的原因有：
- 线程正常终止：
run()方法执行到return语句返回；- 线程意外终止：
run()方法因为未捕获的异常导致线程终止；- 对某个线程的
Thread实例调用stop()方法强制终止（强烈不推荐使用）。
三. 中断线程：
线程中断是指通知一个线程它应该停止当前的工作并尽量提前退出。线程中断并不意味着线程会立即停止执行，而是线程响应中断信号并在适当的地方进行中断处理。Java中提供了对线程中断的支持。
Java中的线程中断是通过 Thread 类的 interrupt() 方法实现的。当一个线程被中断时，线程的中断状态会被设置为 true，线程可以在自己合适的时机检查该中断标志并进行适当的处理。
线程中断的关键方法：
Thread.interrupt()：用于请求中断线程。如果线程正在执行阻塞操作（如sleep()、wait()或join()等），中断将抛出InterruptedException异常；否则只是设置线程的中断标志位为true。
Thread.isInterrupted()：用于检查当前线程是否被中断。
Thread.interrupted()：用于检查当前线程是否被中断并清除中断标志位。
class Task extends Thread {
@Override
public void run() {
while (!isInterrupted()) { // 检查线程的中断标志
try {
// 模拟长时间计算任务
System.out.println("任务正在执行...");
Thread.sleep(1000); // 可能被中断
} catch (InterruptedException e) {
// 如果发生中断，捕获异常并退出
System.out.println("任务被中断，退出.");
break;
}
}
}
}
public class InterruptDemo {
public static void main(String[] args) throws InterruptedException {
Task task = new Task();
task.start();
// 主线程休眠3秒后中断子线程
Thread.sleep(3000);
task.interrupt(); // 请求中断
}
}
为什么用 while 而不用 if 判断？
中断的状态并不是一次性的，它可以被多次设置。Java 中的
Thread.interrupt()方法只是设置线程的中断标志为true，并不会强制终止线程。线程会根据自己的逻辑判断是否响应中断。使用while循环可以确保即使线程在处理过程中发生了阻塞或某些逻辑判断，依然能够持续检查中断标志，及时响应外部的中断请求。
四.守护线程：
守护线程是指为其他线程提供服务的线程，在所有非守护线程结束时，守护线程也会自动终止。守护线程通常用于执行一些后台任务，如垃圾回收器或其他后台服务。
守护线程与非守护线程（用户线程）的最大区别在于，守护线程在没有任何非守护线程存活时自动退出，即使它们自己还在运行。换句话说，守护线程的生命周期是由非守护线程决定的，当所有非守护线程结束时，守护线程会被强制结束。
默认情况下，所有线程都是非守护线程（用户线程）。
我们可以通过
Thread.setDaemon(true)来将线程设置为守护线程。
class DaemonTask extends Thread {
@Override
public void run() {
while (true) {
System.out.println("守护线程正在运行...");
try {
Thread.sleep(1000); // 模拟执行任务
} catch (InterruptedException e) {
break;
}
}
}
}
public class DaemonThreadDemo {
public static void main(String[] args) throws InterruptedException {
DaemonTask daemonTask = new DaemonTask();
daemonTask.setDaemon(true); // 设置为守护线程
daemonTask.start();
// 主线程休眠3秒后结束
Thread.sleep(3000);
System.out.println("主线程结束，守护线程也会自动退出.");
}
}
五.线程的同步：
线程同步（Thread Synchronization）是多线程编程中的一个重要概念，指的是多个线程并发访问共享资源时，为了避免出现竞争条件（Race Condition）或不一致的数据状态，必须确保线程间的执行顺序和对共享资源的访问是有序的。线程同步通常用来保证多个线程对共享数据的访问是互斥的，即在同一时刻，只有一个线程可以访问共享资源。
竞争条件：
竞争条件是指多个线程并发执行时，如果没有正确的同步机制来保证线程间的顺序，可能导致不同线程对共享资源的访问互相干扰，从而造成数据不一致。
例如，下面的代码片段是一个简单的递增计数器，但由于多个线程并发操作，可能会导致计数器的值错误。
class Counter {
private int count = 0;
public void increment() {
count++; // 非原子操作，可能导致数据不一致
}
public int getCount() {
return count;
}
}
public class RaceConditionExample {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final count: " + counter.getCount()); // 期望是 2000，但可能出现不一致
}
}
在这个例子中，由于 count++ 操作并非原子操作，多个线程同时执行时，可能会发生竞争条件，导致最终的计数值不为 2000。
为了防止竞争条件的发生，我们需要对共享资源的访问进行同步。同步能够确保同一时刻只有一个线程能够访问共享资源，从而避免多个线程的操作互相干扰。
在 Java 提供了多种方式来实现线程同步。常见的同步方法有 synchronized 关键字、显式锁（如 ReentrantLock）、volatile 关键字等。
1.使用 synchronized 关键字：
synchronized 关键字是 Java 提供的最基本的同步机制，可以用来保证同一时刻只有一个线程能够访问某个代码块或方法。
synchronized关键字有三种使用方式：
同步实例方法：将
synchronized关键字加在实例方法上，这样每次只有一个线程能够执行该实例方法。同步静态方法：将
synchronized关键字加在静态方法上，这样每次只有一个线程能够执行该静态方法。同步代码块：将
synchronized关键字用于方法内部的代码块，只对特定代码块进行同步，减少性能开销。
（1）同步实例方法：
class Counter {
private int count = 0;
// 使用 synchronized 确保每次只有一个线程可以执行该方法
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
public class SynchronizedExample {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final count: " + counter.getCount()); // 正常输出 2000
}
}
synchronized确保了在同一时刻只有一个线程能够执行increment()方法。- 通过同步方法，
count++操作不会被多个线程同时执行，避免了数据不一致的情况。
（2）同步静态方法：
synchronized static确保了在同一时刻，只有一个线程能够执行increment()静态方法。
class Counter {
private static int count = 0;
// 使用 synchronized 确保每次只有一个线程可以执行该静态方法
public synchronized static void increment() {
count++;
}
public synchronized static int getCount() {
return count;
}
}
public class SynchronizedStaticExample {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final count: " + counter.getCount()); // 正常输出 2000
}
}
（3）同步代码块：
synchronized (this)确保只有一个线程可以执行increment()方法中的关键部分。通过同步代码块，我们可以更精细地控制同步范围，减少性能开销。
class Counter {
private int count = 0;
public void increment() {
synchronized (this) { // 只对特定代码块进行同步
count++;
}
}
public int getCount() {
return count;
}
}
public class SynchronizedBlockExample {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final count: " + counter.getCount()); // 正常输出 2000
}
}
2.使用 volatile 关键字：
volatile 关键字保证了变量的可见性，即线程修改了 volatile 变量的值，其他线程能够立即看到修改后的值。volatile 并不保证原子性，但它可以用于避免一些简单的同步问题，如标志变量的检测。
使用
volatile保证了flag变量的值在不同线程间的可见性。
class SharedResource {
private volatile boolean flag = false;
public void setFlagTrue() {
flag = true; // 设置 flag 为 true
}
public boolean getFlag() {
return flag; // 读取 flag 的值
}
}
3.线程的等待（wait）与唤醒（notify）：
除了常见的线程互斥功能外，synchronized 还提供了一种 等待-唤醒机制，允许线程在特定条件下挂起，并等待其他线程的通知。
这种机制通常用于实现线程间的通信，如 生产者-消费者问题，即线程A在资源不足时进入等待状态，而线程B则在资源有了后通知线程A继续执行。
等待-唤醒机制基本概念：
- 等待（
wait()）：当线程执行到某一条件不满足时，使用wait()让该线程进入等待状态，释放持有的锁，直到其他线程通过调用notify()或notifyAll()唤醒它。- 唤醒（
notify()或notifyAll()）：当某些条件改变时，其他线程调用notify()或notifyAll()唤醒处于等待状态的线程。notify()唤醒一个线程，notifyAll()唤醒所有等待的线程
关键方法说明
wait()：使当前线程进入等待状态，释放持有的锁，直到其他线程调用notify()或notifyAll()唤醒它。wait()必须在同步块或同步方法中调用。使当前线程等待，并且释放持有的锁。
notify()：唤醒一个等待的线程。如果多个线程在等待该对象的监视器（锁），notify()会唤醒其中一个线程（具体哪个线程无法确定）。
notifyAll()：唤醒所有等待的线程，所有等待该对象监视器的线程都会被唤醒。
wait()和notify()只能在同步块或同步方法中调用，因为它们依赖于对象的监视器（锁）。在同步方法内调用时，该方法的锁是当前对象；在同步代码块内，锁是传入的对象。在调用
wait()时，线程会释放当前的锁，允许其他线程获取锁。当该线程被唤醒后，它会重新尝试获取锁。
class BoundedBuffer {
private int[] buffer;
private int count = 0; // 缓冲区中的元素个数
private int putIndex = 0; // 下一次插入的位置
private int takeIndex = 0; // 下一次取出的位置
// 创建缓冲区
public BoundedBuffer(int size) {
buffer = new int[size];
}
// 生产者放入数据
public synchronized void put(int value) throws InterruptedException {
while (count == buffer.length) { // 如果缓冲区满
wait(); // 生产者等待
}
buffer[putIndex] = value;
putIndex = (putIndex + 1) % buffer.length; // 循环插入
count++;
notifyAll(); // 通知消费者可以取数据了
}
// 消费者取出数据
public synchronized int take() throws InterruptedException {
while (count == 0) { // 如果缓冲区空
wait(); // 消费者等待
}
int value = buffer[takeIndex];
takeIndex = (takeIndex + 1) % buffer.length; // 循环取出
count--;
notifyAll(); // 通知生产者可以放数据了
return value;
}
}
public class ProducerConsumer {
public static void main(String[] args) throws InterruptedException {
BoundedBuffer buffer = new BoundedBuffer(10);
// 生产者线程
Thread producer = new Thread(() -> {
try {
for (int i = 0; i < 100; i++) {
buffer.put(i);
System.out.println("Produced: " + i);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
// 消费者线程
Thread consumer = new Thread(() -> {
try {
for (int i = 0; i < 100; i++) {
int value = buffer.take();
System.out.println("Consumed: " + value);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
producer.start();
consumer.start();
producer.join();
consumer.join();
}
}
4.使用 ReentrantLock锁：
在 Java 中，多线程同步的传统方法是使用 synchronized 关键字。虽然 synchronized 简单易用，但它存在一些不足之处，如无法精确控制锁的获取和释放、缺少条件等待和通知机制等。为了解决这些问题，Java 提供了显式锁机制 ReentrantLock（可重入锁）和 Condition 类，能够提供更多的灵活性和控制。
ReentrantLock 是 java.util.concurrent.locks 包下的一个类，它是一个可重入的互斥锁，允许在一个线程中多次获取同一个锁，并且能够提供比 synchronized 更灵活的功能。
ReentrantLock提供了对count++操作的显式同步，保证了并发情况下count的值是正确的。lock.lock()获取锁，lock.unlock()释放锁。如果忘记调用unlock()，可能会导致死锁问题，因此需要确保在finally块中释放锁。
import java.util.concurrent.locks.ReentrantLock;
class Counter {
private int count = 0;
private final ReentrantLock lock = new ReentrantLock();
// 使用 ReentrantLock 进行线程同步
public void increment() {
lock.lock(); // 获取锁
try {
count++;
} finally {
lock.unlock(); // 释放锁
}
}
public int getCount() {
return count;
}
}
public class ReentrantLockExample {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final count: " + counter.getCount()); // 正常输出 2000
}
}
对于ReentrantLock锁的等待与唤醒：
Condition 是与 ReentrantLock 配合使用的一个接口，它允许线程在满足某个条件时进行等待或通知，类似于传统的 Object.wait() 和 Object.notify() 方法。Condition 提供了更多的控制选项，可以精确控制等待和通知的条件。
Condition 的常用方法：
await()：使当前线程等待，直到被其他线程通知或者中断。
signal()：唤醒一个等待的线程，使其能够继续执行。
signalAll()：唤醒所有等待的线程，使它们能够继续执行。
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
class BoundedBuffer {
private final int[] buffer; // 缓冲区
private int count = 0;
private int putIndex = 0;
private int takeIndex = 0;
private final ReentrantLock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition(); // 缓冲区不满时的条件
private final Condition notEmpty = lock.newCondition(); // 缓冲区不空时的条件
public BoundedBuffer(int size) {
buffer = new int[size];
}
public void put(int value) throws InterruptedException {
lock.lock();
try {
while (count == buffer.length) {
notFull.await(); // 如果缓冲区满，等待
}
buffer[putIndex] = value;
if (++putIndex == buffer.length) {
putIndex = 0; // 环形缓冲区
}
count++;
notEmpty.signal(); // 唤醒等待取数据的线程
} finally {
lock.unlock();
}
}
public int take() throws InterruptedException {
lock.lock();
try {
while (count == 0) {
notEmpty.await(); // 如果缓冲区为空，等待
}
int value = buffer[takeIndex];
if (++takeIndex == buffer.length) {
takeIndex = 0; // 环形缓冲区
}
count--;
notFull.signal(); // 唤醒等待放数据的线程
return value;
} finally {
lock.unlock();
}
}
}
public class ProducerConsumerExample {
public static void main(String[] args) throws InterruptedException {
BoundedBuffer buffer = new BoundedBuffer(10);
// 生产者线程
Thread producer = new Thread(() -> {
try {
for (int i = 0; i < 100; i++) {
buffer.put(i);
System.out.println("Produced: " + i);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
// 消费者线程
Thread consumer = new Thread(() -> {
try {
for (int i = 0; i < 100; i++) {
int value = buffer.take();
System.out.println("Consumed: " + value);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
producer.start();
consumer.start();
producer.join();
consumer.join();
}
}
六.线程池的使用：
在多线程编程中，创建和销毁线程是一个非常耗费资源的操作。如果频繁地创建和销毁线程，会导致性能下降，甚至可能引发系统崩溃。因此，Java 提供了 线程池 的机制来管理线程的生命周期，避免每次任务执行时都需要创建新线程。
线程池是一种常用的设计模式，可以复用已创建的线程，而不是每次都创建新线程。Java 提供了 Executor 框架来管理线程池及其任务。
1.线程池的核心接口和实现：
Executor：是线程池的核心接口，提供了执行任务的方法。
public interface Executor {
void execute(Runnable command);
}
ExecutorService：是 Executor 的子接口，提供了更多的功能，比如管理线程池、提交任务、关闭线程池等。
public interface ExecutorService extends Executor {
void shutdown();
List<Runnable> shutdownNow();
<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
}
ThreadPoolExecutor：是 ExecutorService 的常用实现类，提供了线程池的管理功能。它是一个可定制化的线程池实现。
ScheduledExecutorService：继承了 ExecutorService，用于执行定时任务。
2. 线程池的常见实现类：
FixedThreadPool：创建一个固定大小的线程池。线程池中的线程数量固定，任务会在空闲的线程上执行。适用于任务量较大、每个任务执行时间相似的场景。
CachedThreadPool：创建一个可缓存的线程池。如果线程池中的线程空闲超过60秒，则会被回收。适用于任务量不确定，且每个任务的执行时间较短的场景。
SingleThreadExecutor：创建一个只有一个线程的线程池，适用于任务顺序执行的场景。
ScheduledThreadPoolExecutor：用于执行定时任务，支持延时执行任务、周期性任务等
3.创建线程池：
（1）使用 Executors 工厂类创建线程池：
Java 提供了 Executors 类来创建各种类型的线程池。以下是一些常见的线程池创建方式：
import java.util.concurrent.*;
public class ThreadPoolExample {
public static void main(String[] args) {
// 固定大小线程池
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
// 可缓存线程池
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 单线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
// 定时线程池
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
}
}
（2）使用 ThreadPoolExecutor 直接创建线程池：
ThreadPoolExecutor 提供了更灵活的创建方式，可以定制线程池的各个参数。常用的构造方法如下：
ThreadPoolExecutor(
int corePoolSize, // 核心池大小（即使没有任务时，线程池也会保留的最小线程数）
int maximumPoolSize, // 最大池大小（线程池能够容纳的最大线程数）
long keepAliveTime, // 空闲线程存活时间（当线程池中的线程数大于 corePoolSize 时，空闲线程的最大存活时间）
TimeUnit unit, // 时间单位
BlockingQueue<Runnable> workQueue // 用于保存任务的阻塞队列
// LinkedBlockingQueue：无界队列
// ArrayBlockingQueue：有界队列
// PriorityBlockingQueue：优先级队列
)
4.线程池的常用方法：
（1）submit()：
submit() 方法可以提交一个 Runnable 或 Callable 任务，返回一个 Future 对象，允许在任务完成后获取其结果。
ExecutorService executor = Executors.newFixedThreadPool(3);
Future<Integer> future = executor.submit(() -> {
// 任务逻辑
return 123;
});
Integer result = future.get(); // 获取任务执行结果
System.out.println(result);
（2）shutdown() 和 shutdownNow()：
executor.shutdown(); // 启动关闭过程，等待所有任务完成
executor.shutdownNow(); // 尝试停止正在执行的任务
（3）invokeAll() 和 invokeAny()：
- invokeAll()：一次执行多个任务，并返回所有任务的
Future列表，等待所有任务完成。- invokeAny()：一次执行多个任务，返回最先完成任务的结果。
List<Callable<Integer>> tasks = new ArrayList<>();
tasks.add(() -> 1);
tasks.add(() -> 2);
ExecutorService executor = Executors.newFixedThreadPool(3);
List<Future<Integer>> futures = executor.invokeAll(tasks);
for (Future<Integer> future : futures) {
System.out.println(future.get());
}
Integer result = executor.invokeAny(tasks); // 返回第一个完成的任务结果
System.out.println(result);
七.ThreadLocal的使用：
ThreadLocal 是 Java 提供的一种用于解决多线程并发问题的机制。它能够为每个线程提供独立的变量副本，这样多个线程访问同一个 ThreadLocal 变量时，各自的副本不会相互影响，避免了线程安全问题。
在多线程环境下，通常多个线程会共享某些数据，但如果多个线程同时访问同一份数据，可能会引发数据竞争和线程安全问题。ThreadLocal 通过为每个线程提供独立的副本来解决这一问题。
1.什么是ThreadLocal：
ThreadLocal 提供了一个每个线程私有的变量副本。每个线程在首次访问 ThreadLocal 时，会为该线程创建一个 ThreadLocal 变量的副本。之后同一线程访问该变量时，将直接操作该线程的副本，而不会与其他线程的副本发生冲突。
每个线程可以通过
ThreadLocal变量独立地获取、设置自己的值。
2.ThreadLocal的工作原理：
ThreadLocal 工作的核心是 线程隔离。每个线程都有自己独立的 ThreadLocal 变量副本，访问这个副本的操作不会影响其他线程的副本。每个线程都有一个与 ThreadLocal 对象关联的 线程本地存储。
具体而言：
- 当线程第一次访问
ThreadLocal变量时，系统会创建该线程本地的副本并初始化它。- 每个线程可以通过
ThreadLocal类提供的get()和set()方法来获取和设置它的本地副本。- 不同线程间互不干扰，
ThreadLocal实现了线程数据隔离。
3.ThreadLocal的常见方法：
（1）get()：获取当前线程对 ThreadLocal 变量的副本。
public T get();
（2）set(T value)：设置当前线程对 ThreadLocal 变量的副本。
public void set(T value);
（3）initialValue()：返回当前线程对 ThreadLocal 变量的初始值。如果没有设置初始值，会调用此方法生成。
protected T initialValue();
4.应用场景：
在下面的例子中：
threadLocal是一个ThreadLocal<Integer>变量，它为每个线程维护了一个独立的副本。- 通过
threadLocal.get()和threadLocal.set()，每个线程操作的是自己私有的副本，互不干扰。- 线程1和线程2的初始值都是
1，但是它们在各自的上下文中可以独立地修改这个值。
public class ThreadLocalExample {
private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 1);
public static void main(String[] args) {
// 启动多个线程来演示 ThreadLocal 的使用
Thread thread1 = new Thread(() -> {
System.out.println("Thread 1 initial value: " + threadLocal.get()); // 1
threadLocal.set(2);
System.out.println("Thread 1 new value: " + threadLocal.get()); // 2
});
Thread thread2 = new Thread(() -> {
System.out.println("Thread 2 initial value: " + threadLocal.get()); // 1
threadLocal.set(3);
System.out.println("Thread 2 new value: " + threadLocal.get()); // 3
});
thread1.start();
thread2.start();
}
}
ThreadLocal的withInitial方法允许你指定一个初始值。如果线程没有显式设置值，ThreadLocal会使用该初始值。ThreadLocal<String> threadLocal = ThreadLocal.withInitial(() -> "Default Value"); public class ThreadLocalExample { public static void main(String[] args) { System.out.println(threadLocal.get()); // 输出: Default Value } }
八.虚拟线程的使用：
1.什么是虚拟线程：
虚拟线程是 JEP 436 中提出的一项新特性，旨在简化 Java 并发编程并提高应用程序的可扩展性。虚拟线程是基于 轻量级线程（Lightweight Threads）设计的，它们由 Java 虚拟机（JVM）进行调度，而不是由操作系统进行调度。虚拟线程的引入将有助于大规模并发编程，特别是在需要大量并发线程的应用场景中（如 Web 服务器、异步 I/O 等）。
虚拟线程的目标是提供与传统的操作系统线程（称为“平台线程”）相同的编程模型，但它们在系统资源的使用上更加高效，从而显著提高程序的并发性能。
2.创建虚拟线程：
虚拟线程可以通过 Thread.ofVirtual() 方法创建，或者通过 ExecutorService 来管理虚拟线程池。
public class VirtualThreadExample {
public static void main(String[] args) {
Thread virtualThread = Thread.ofVirtual().start(() -> {
System.out.println("Virtual thread is running!");
});
// 等待线程执行完毕
try {
virtualThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
3.通过虚拟线程池管理虚拟线程：
我们可以使用 ExecutorService 来管理虚拟线程池，这样可以简化多线程管理。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class VirtualThreadExecutorExample {
public static void main(String[] args) {
// 创建一个虚拟线程池
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
// 提交任务到虚拟线程池
for (int i = 0; i < 10; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("Task " + taskId + " is running on virtual thread.");
});
}
// 关闭线程池
executor.shutdown();
}
}
4.虚拟线程的 I/O 操作：
虚拟线程特别适合 I/O 密集型操作。使用虚拟线程时，JVM 会自动挂起不活跃的线程并将 CPU 资源分配给其他线程，从而避免了传统线程模型中因为 I/O 操作导致线程空闲的资源浪费。
import java.util.concurrent.*;
public class IOBlockingExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
for (int i = 0; i < 10; i++) {
final int taskId = i;
executor.submit(() -> {
try {
System.out.println("Task " + taskId + " starts I/O operation.");
// 模拟 I/O 操作
Thread.sleep(1000);
System.out.println("Task " + taskId + " finishes I/O operation.");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
executor.shutdown();
}
}