绿叶随笔 | 详情

线程创建方式

继承Thread类：

这种方式需要创建一个类，继承自Thread类，并重写其run()方法来定义线程的执行逻辑。然后可以创建该类的实例并调用start()方法启动线程。

class MyThread extends Thread {
    public void run() {
        // 线程执行的逻辑
    }
}

MyThread thread = new MyThread();
thread.start();

实现Runnable接口：

这种方式需要创建一个类，实现Runnable接口，并实现其run()方法来定义线程的执行逻辑。然后可以创建该类的实例并将其作为参数传递给Thread类的构造函数，最后调用start()方法启动线程。

class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的逻辑
    }
}

Thread thread = new Thread(new MyRunnable());
thread.start();

实现Callable接口：

与Runnable接口类似，但Callable接口的call()方法可以返回结果或抛出异常。可以通过FutureTask类包装Callable对象，然后传递给Thread类进行启动。

class MyCallable implements Callable<Integer> {
    public Integer call() {
        // 线程执行的逻辑
        return result;
    }
}

FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());
Thread thread = new Thread(futureTask);
thread.start();

线程池创建：

使用线程池可以管理和复用线程，避免频繁创建和销毁线程带来的性能开销。可以通过Executors工厂类来创建不同类型的线程池，如FixedThreadPool、CachedThreadPool、ScheduledThreadPool等。

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.execute(new MyRunnable());
executor.shutdown();

Object类

wait()方法：使当前线程进入等待状态，直到其他线程调用notify()或notifyAll()方法唤醒它。wait()方法通常与synchronized关键字一起使用，在同步块中调用。

synchronized(obj) {
    obj.wait(); // 当前线程等待
}

**wait(long timeout)和wait(long timeout, int nanos)**方法：与wait()方法类似，但是可以指定等待的时间，超过指定时间后会自动唤醒线程。

synchronized(obj) {
    obj.wait(1000); // 等待1秒钟，超时后自动唤醒
}

notify()方法：唤醒在该对象上等待的单个线程。如果多个线程在对象上等待，那么只会唤醒其中一个线程，具体唤醒哪个线程是不确定的。

synchronized(obj) {
    obj.notify(); // 唤醒等待的线程
}

notifyAll()方法：唤醒在该对象上等待的所有线程。这样所有等待的线程都有机会继续执行，但是只有一个线程能够获取对象的锁。

synchronized(obj) {
    obj.notifyAll(); // 唤醒所有等待的线程
}

stop()：终止线程（已过时）、这种方式存在很大的缺点：容易丢失数据、因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失。不建议使用

Thread类

Thread类属性

ApartmentState：获取或设置该线程的单元状态
CurrentContext：获取线程正在其中执行的当前上下文
CurrentThread：获取当前正在运行的线程
IsAlive：获取一个值，该值指示当前线程的执行状态
ManagedThreadId：获取当前托管线程的唯一标识符
Name：获取或设置线程的名称
Priority：获取或设置一个值，该值指示x线程的调度优先级
- 最低优先级1
- 默认优先级是5
- 最高优先级10
ThreadState：获取一个值，该值包含当前线程的状态

Thread类方法

start()：启动线程，使其进入可执行状态，当CPU调度到该线程时，会执行其run()方法。

Thread thread = new Thread(new MyRunnable());
thread.start();

run()：定义线程的执行逻辑，需要在自定义的Thread类中重写该方法。

class MyThread extends Thread {
    public void run() {
        // 线程执行的逻辑
    }
}

join()：等待该线程终止。在当前线程中调用另一个线程的join()方法，会使当前线程阻塞，直到另一个线程执行完毕。

Thread thread = new Thread(new MyRunnable());
thread.start();
thread.join(); // 等待thread线程执行完毕

sleep(long millis)和sleep(long millis, int nanos)：使当前线程暂停执行指定的时间。注意，sleep()方法不会释放对象锁。

Thread.sleep(1000); // 暂停1秒钟

interrupt()：中断该线程。通常与线程的中断机制一起使用，通过设置线程的中断状态来请求线程停止执行。

thread.interrupt(); // 中断线程

isInterrupted()和interrupted()：用于检查线程的中断状态。isInterrupted()检查指定线程的中断状态，而interrupted()检查当前线程的中断状态，并清除中断状态。

if (Thread.currentThread().isInterrupted()) {
    // 线程已被中断
}

yield()：暂停当前正在执行的线程，并允许其他线程执行。该方法会提示线程调度器当前线程愿意让出CPU资源，但不保证线程调度器一定会满足这一愿望。

Thread.yield(); // 暂停当前线程，让出CPU资源

Callable

理论

（1）callable原理分析

Future 接口

当 call（）方法完成时，结果必须存储在主线程已知的对象中，以便主线程可以知道该线程返回的结果。为此，可以使用 Future 对象。将 Future 视为保存结果的对象–它可能暂时不保存结果，但将来会保存（一旦Callable 返回）。Future 基本上是主线程可以跟踪进度以及其他线程的结果的一种方式。要实现此接口，必须重写 5 种方法，这里列出了重要的方法,如下: • public boolean cancel（boolean mayInterrupt）：用于停止任务。如果尚未启动，它将停止任务。如果已启动，则仅在mayInterrupt 为 true时才会中断任务。 • public Object get（）抛出 InterruptedException，ExecutionException：用于获取任务的结果。如果任务完成，它将立即返回结果，否则将等待任务完成，然后返回结果。

• public boolean isDone（）：如果任务完成，则返回 true，否则返回 false可以看到 Callable 和 Future 做两件事-Callable 与 Runnable 类似，因为它封装了要在另一个线程上运行的任务，而 Future 用于存储从另一个线程获得的结果。实际上，future 也可以与 Runnable 一起使用。要创建线程，需要 Runnable。为了获得结果，需要 future。

FutureTask

Java 库具有具体的 FutureTask 类型，该类型实现 Runnable 和 Future，并方便地将两种功能组合在一起。可以通过为其构造函数提供 Callable 来创建FutureTask。然后，将 FutureTask 对象提供给 Thread 的构造函数以创建Thread 对象。因此，间接地使用 Callable 创建线程。

（2）callable应用场景

• 在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成, 当主线程将来需要时，就可以通过 Future对象获得后台作业的计算结果或者执行状态 • 一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果 • 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。 • 只计算一次

（3）核心原理:

在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成 • 当主线程将来需要时，就可以通过 Future 对象获得后台作业的计算结果或者执行状态 • 一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。 • 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法 • 一旦计算完成，就不能再重新开始或取消计算 • get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常 • get 只计算一次,因此 get 方法放到最后

语法

与Runnable接口类似，但Callable接口的call()方法可以返回结果或抛出异常。可以通过FutureTask类包装Callable对象，然后传递给Thread类进行启动。

class MyCallable implements Callable<Integer> {
    public Integer call() {
        // 线程执行的逻辑
        return result;
    }
}

FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());
Thread thread = new Thread(futureTask);
thread.start();

线程池

理论

（1）线程池

一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。

（2）线程池的优势

线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

（3）线程池的特点

• 降低资源消耗: 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。 • 提高响应速度: 当任务到达时，任务可以不需要等待线程创建就能立即执行。 • 提高线程的可管理性: 线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

（4）线程池底层工作原理(重要)

在创建了线程池后，线程池中的线程数为零
当调用 execute()方法添加一个请求任务时，线程池会做出如下判断：

2.1 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务； 2.2 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；

2.3 如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；

2.4 如果队列满了且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。

当一个线程完成任务时，它会从队列中取下一个任务来执行
当一个线程无事可做超过一定的时间（keepAliveTime）时，线程会判断： 4.1 如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。

4.2所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

（5）创建线程池推荐 ThreadPoolExecutor而不是 Executors

项目中创建多线程时，使用常见的三种线程池创建方式，单一、可变、定长都有一定问题，原因是 FixedThreadPool 和 SingleThreadExecutor 底层都是用LinkedBlockingQueue 实现的，这个队列最大长度为 Integer.MAX_VALUE，容易导致 OOM。所以实际生产一般自己通过 ThreadPoolExecutor 的 7 个参数，自定义线程池

线程池相关类

Java 中的线程池是通过 Executor 框架实现的，该框架中用到了 Executor，Executors，ExecutorService，ThreadPoolExecutor 这几个类

Executor

一个执行提交的任务的对象的简单接口。它提供了一种将任务提交与执行策略分离的方式，使得可以方便地实现不同的任务调度和执行策略。

void execute(Runnable command)：用于执行传入的任务。具体任务的执行方式可以由 Executor 的实现类来决定，例如同步执行、异步执行、并行执行等。

Executors

用于创建各种类型的线程池。它提供了一系列静态工厂方法，用于创建不同配置的线程池，从而简化了线程池的创建和管理过程。

newCachedThreadPool()： 创建一个可缓存的线程池，线程数量根据需求动态调整。如果线程池的线程数量超过了任务需求，多余的线程将会被回收，如果需要，线程池将会创建新的线程。
newFixedThreadPool(int nThreads)： 创建一个固定大小的线程池，线程数量固定，不会随着任务的增加而增加。当所有线程都处于活动状态时，新任务将会在队列中等待。
newSingleThreadExecutor()： 创建一个单线程的线程池，该线程池只有一个工作线程，保证所有任务按顺序执行。
newScheduledThreadPool(int corePoolSize)： 创建一个固定大小的线程池，可以执行定时任务或者周期性任务。

ExecutorService

扩展了 Executor 接口，提供了更丰富的任务提交、执行和管理功能。相比于 Executor 接口，ExecutorService 接口更适合于需要管理任务执行状态、获取任务执行结果等场景。

submit(Runnable task)： 提交一个 Runnable 任务给线程池执行，并返回一个表示该任务执行情况的 Future 对象。
submit(Callable<T> task)： 提交一个 Callable 任务给线程池执行，并返回一个表示该任务执行情况的 Future 对象，可以通过该对象获取任务执行的结果。
invokeAll(Collection<? extends Callable<T>> tasks)： 执行给定的任务集合，并返回一个包含 Future 对象的列表，每个 Future 对象表示相应任务的执行情况。
invokeAny(Collection<? extends Callable<T>> tasks)： 执行给定的任务集合，返回其中某一个任务的执行结果，无法保证返回的是哪个任务的结果。
shutdown()： 立即关闭线程池，并拒绝接受新任务，但会等待已提交的任务执行完毕。
shutdownNow()： 尝试立即关闭线程池，取消所有正在执行的任务，并且不再处理等待中的任务。
isShutdown()： 判断线程池是否已经关闭。
isTerminated()： 判断所有任务是否已经执行完毕，或者线程池是否已经被关闭。

ThreadPoolExecutor

提供了一个灵活而强大的线程池管理机制，可以用来管理和复用线程，从而有效地处理并发任务。

通过合理地配置这些参数，可以根据实际情况创建出满足需求的线程池。ThreadPoolExecutor 提供了非常灵活和强大的线程池管理机制，适用于各种多线程场景下的任务调度和执行。

参数：

corePoolSize（核心线程数）： 线程池中始终保持的活动线程数，即使它们处于空闲状态。如果提交的任务数多于核心线程数，线程池会根据情况创建新的线程来处理任务，直到达到最大线程数。
maximumPoolSize（最大线程数）： 线程池允许的最大线程数，包括核心线程数和额外创建的线程数。当队列满了且当前线程数小于最大线程数时，线程池会创建新的线程来处理任务，直到达到最大线程数。
keepAliveTime（线程空闲时间）： 当线程池中的线程数量超过核心线程数时，多余的空闲线程在被终止之前等待新任务的最长时间。超过这个时间后，空闲线程将被终止直到线程池中的线程数等于核心线程数。
unit（时间单位）： 空闲时间的时间单位。
workQueue（工作队列）： 用于保存等待执行的任务的阻塞队列。当线程池中的线程数达到核心线程数时，新提交的任务会被放入工作队列中等待执行。
threadFactory（线程工厂）： 用于创建新线程的工厂。
handler（拒绝策略）： 当线程池和工作队列都满了，无法继续处理新任务时，如何处理新任务的策略。

创建线程池方式（ThreadPoolExecutor对象）

参数

• corePoolSize 线程池的核心线程数 • maximumPoolSize 能容纳的最大线程数 • keepAliveTime 空闲线程存活时间 • unit 存活的时间单位 • workQueue 存放提交但未执行任务的队列 • threadFactory 创建线程的工厂类 • handler 等待队列满后的拒绝策略

原理

线程池中，有三个重要的参数，决定影响了拒绝策略：corePoolSize - 核心线程数，也即最小的线程数、workQueue - 阻塞队列、maximumPoolSize -最大线程数。当提交任务数大于 corePoolSize 的时候，会优先将任务放到 workQueue 阻塞队列中。当阻塞队列饱和后，会扩充线程池中线程数，直到达到maximumPoolSize 最大线程数配置。此时，再多余的任务，则会触发线程池的拒绝策略了。总结起来，也就是一句话，当提交的任务数大于（workQueue.size() +maximumPoolSize ），就会触发线程池的拒绝策略。

拒绝策略(重点)

CallerRunsPolicy: 当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。一般并发比较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大 AbortPolicy: 丢弃任务，并抛出拒绝执行 RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行。 DiscardPolicy: 直接丢弃，其他啥都没有 DiscardOldestPolicy: 当触发拒绝策略，只要线程池没有关闭的话，丢弃阻塞队列 workQueue 中最老的一个任务，并将新任务加入

使用

//自定义线程池创建
public class ThreadPoolDemo2 {
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                2L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        //10个顾客请求
        try {
            for (int i = 1; i <=10; i++) {
                //执行
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" 办理业务");
                });
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭
            threadPool.shutdown();
        }
    }
}

创建线程池方式（Executors静态方法）

newCachedThreadPool(常用)

作用：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程. 特点: • 线程池中数量没有固定，可达到最大值（Interger. MAX_VALUE） • 线程池中的线程可进行缓存重复利用和回收（回收默认时间为 1 分钟） • 当线程池中，没有可用线程，会重新创建一个线程

场景:

适用于创建一个可无限扩大的线程池，服务器负载压力较轻，执行时间较短，任务多的场景

使用：

ExecutorService threadPool1 = Executors.newCachedThreadPool(5); 

public static ExecutorService newCachedThreadPool(){
/**
* corePoolSize 线程池的核心线程数
* maximumPoolSize 能容纳的最大线程数
* keepAliveTime 空闲线程存活时间
* unit 存活的时间单位
* workQueue 存放提交但未执行任务的队列
* threadFactory 创建线程的工厂类:可以省略
* handler 等待队列满后的拒绝策略:可以省略
*/
return new ThreadPoolExecutor(0,
Integer.MAX_VALUE,
60L,
TimeUnit.SECONDS,
new SynchronousQueue<>(),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
}

newFixedThreadPool(常用)

作用：

创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。

特征：

• 线程池中的线程处于一定的量，可以很好的控制线程的并发量 • 线程可以重复被使用，在显示关闭之前，都将一直存在 • 超出一定量的线程被提交时候需在队列中等待

场景:

适用于可以预测线程数量的业务中，或者服务器负载较重，对线程数有严格限制的场景

使用：

ExecutorService threadPool1 = Executors.newFixedThreadPool(5); //5个窗口

public static ExecutorService newFixedThreadPool(){
/**
* corePoolSize 线程池的核心线程数
* maximumPoolSize 能容纳的最大线程数
* keepAliveTime 空闲线程存活时间
* unit 存活的时间单位
* workQueue 存放提交但未执行任务的队列
* threadFactory 创建线程的工厂类:可以省略
* handler 等待队列满后的拒绝策略:可以省略
*/
return new ThreadPoolExecutor(10,
10,
0L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
}

newSingleThreadExecutor(常用)

作用：

创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的newFixedThreadPool 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。特征：线程池中最多执行 1 个线程，之后提交的线程活动将会排在队列中以此执行

场景:

适用于需要保证顺序执行各个任务，并且在任意时间点，不会同时有多个线程的场景

使用：

public static ExecutorService newSingleThreadExecutor(){
/**
* corePoolSize 线程池的核心线程数
* maximumPoolSize 能容纳的最大线程数
* keepAliveTime 空闲线程存活时间
* unit 存活的时间单位
* workQueue 存放提交但未执行任务的队列
* threadFactory 创建线程的工厂类:可以省略
* handler 等待队列满后的拒绝策略:可以省略
*/
return new ThreadPoolExecutor(1,
1,
0L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
}

newScheduleThreadPool(了解)

作用: 线程池支持定时以及周期性执行任务，创建一个 corePoolSize 为传入参数，最大线程数为整形的最大数的线程池特征: （1）线程池中具有指定数量的线程，即便是空线程也将保留

（2）可定时或者延迟执行线程活动

场景: 适用于需要多个后台线程执行周期任务的场景

创建方式:

public static ScheduledExecutorService newScheduledThreadPool(int
corePoolSize,
ThreadFactory threadFactory) {
return new ScheduledThreadPoolExecutor(corePoolSize,
threadFactory);
}

newWorkStealingPool（了解）

jdk1.8 提供的线程池，底层使用的是 ForkJoinPool 实现，创建一个拥有多个任务队列的线程池，可以减少连接数，创建当前可用 cpu 核数的线程来并行执行任务

场景: 适用于大耗时，可并行执行的场景

创建方式:

public static ExecutorService newWorkStealingPool(int parallelism) {
/**

* parallelism：并行级别，通常默认为 JVM 可用的处理器个数
* factory：用于创建 ForkJoinPool 中使用的线程。
* handler：用于处理工作线程未处理的异常，默认为 null
* asyncMode：用于控制 WorkQueue 的工作模式:队列---反队列
  */
  return new ForkJoinPool(parallelism,
  ForkJoinPool.defaultForkJoinWorkerThreadFactory,
  null,
  true);
  }