Java线程池相关问题

小叮当321

于 2024-08-20 14:46:07 发布

阅读量303

点赞数 18

分类专栏：开发知识点技巧文章标签： java 开发语言

本文链接：https://blog.csdn.net/chb414751843/article/details/141358385

版权

开发知识点技巧专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Java线程池相关问题

Java中一个线程的生命周期

Java中线程的生命周期是指线程从创建到消亡的整个过程。线程的生命周期可以划分为几个不同的状态，这些状态是线程在其生命周期中可能经历的不同阶段。Java线程的生命周期主要包括以下几个状态：

新建状态（New）：当使用new关键字创建一个线程对象时，该线程就处于新建状态。此时，线程对象已经被创建，但还没有被启动（即没有调用线程的start()方法）。
就绪状态（Runnable）：当线程对象调用了start()方法之后，该线程就进入了就绪状态。处于就绪状态的线程已经具备了运行的条件，但是否立即运行取决于JVM的线程调度器。此时，线程可能还在等待获取CPU资源。
运行状态（Running）：当线程获得了CPU时间片，也就是线程调度器选中一个处于就绪状态的线程，使其占用CPU时，该线程就进入了运行状态。在运行状态中，线程执行它的run()方法中的代码。
阻塞状态（Blocked）：线程在运行过程中，可能会因为某些原因（如等待I/O操作完成、等待获取某个锁等）而暂时停止执行，此时线程就进入了阻塞状态。阻塞状态是线程生命周期中的一个中间状态，当阻塞的原因被消除时（如I/O操作完成、获得了锁），线程会重新进入就绪状态。
等待状态（Waiting）：线程在等待某个条件成立时，会进入等待状态。比如，调用了Object.wait()方法、Thread.join()方法或LockSupport.park()方法，线程就会进入等待状态。等待状态的线程不会占用CPU资源，直到其他线程显式地唤醒它（如通过Object.notify()或Object.notifyAll()方法，或者LockSupport.unpark()方法）。
超时等待状态（Timed Waiting）：与等待状态类似，但超时等待状态的线程会在指定的时间后自动返回到就绪状态，而不需要其他线程的唤醒。比如，调用了Thread.sleep(long millis)方法、Object.wait(long timeout)方法或LockSupport.parkNanos(long nanos)等方法的线程会进入超时等待状态。
终止状态（Terminated）：当线程的run()方法执行完毕，或者因为执行过程中遇到异常而退出时，线程就进入了终止状态。处于终止状态的线程不会再执行任何操作，也不会再占用系统资源。

需要注意的是，线程的某些状态转换是依赖于JVM的线程调度器的，如就绪状态到运行状态的转换；而另一些状态转换则是由线程自身或其他线程控制的，如等待状态到就绪状态的转换。了解线程的生命周期和状态转换对于编写高效、可靠的并发程序至关重要。

线程池大小设置为多少更加合适

一般情况下，需根据任务类型的不同设置不同的线程数：

CPU密集型，则线程池大小设置为：cpu核数+1

I/O密集型，则线程池大小设置为：2*cpu核数+1

CPU密集型任务

对于CPU密集型任务，线程池的大小应该与CPU的核心数相匹配，以避免过多的线程竞争CPU资源而导致上下文切换开销过大。通常设置为cpu核数 + 1是一个保守但安全的做法，这样可以确保在大部分情况下，CPU都保持忙碌状态，同时留有一个额外的线程来处理可能的突发任务或进行短暂的等待操作。

I/O密集型任务

对于I/O密集型任务，由于线程在大部分时间里都在等待I/O操作完成（如网络请求、文件读写等），因此可以设置更多的线程来利用这些等待时间。设置为2*cpu核数 + 1是一个常见的做法，这样可以在一个线程等待I/O操作时，让其他线程继续执行，从而更有效地利用CPU资源。然而，这个值也需要根据实际的I/O等待时间和CPU处理能力进行调整。

什么是线程池？它的核心原理是什么？

线程池是一种池化的技术，它的核心思想是为了减少每次获取和结束资源的消耗，提高对资源的利用率。

线程池基本概念

线程重用：线程池中的线程在执行完任务之后不会被销毁，而是可以被重新利用来执行新的任务。

任务队列：当所有线程都在忙碌时，新的任务会被放入一个队列中等待执行。

线程管理：包括线程的创建、销毁、任务分配等。

线程池的好处

降低资源消耗：通过重复利用现有的线程来执行任务，减少了线程创建和销毁的开销。

提高响应速度：线程的创建是需要时间和资源的，利用现有的线程执行任务，省去了创建线程的时间，拿到任务后可以立刻执行。

提高线程的可管理性：线程是一种稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统地稳定性。使用线程池可以进行统一地分配、调优和监控。

线程池有哪几种类型？各有什么优缺点?

CacheThreadPool:可缓存线程池

优点：线程池数量可以动态调整，适用于任务数量多且不需要固定线程池数地场景

缺点：如果任务数量过多，会导致线程数激增，消耗大量系统资源

FixedThreadPool:固定大小线程池

优点：线程数量固定，避免过多线程同时运行导致资源耗尽

缺点：如果任务数量过多，可能会导致队列中的任务积压，导致线程池无法及时处理任务。同时会导致内存泄漏。

SingleThreadExecutor:单线程化线程池

优点：仅有一个线程，可以避免多线程并发问题

缺点：任务处理速度受限于单个线程的能力。如果线程发生异常导致退出，可能会有未执行完的任务

ScheduledThreadPool:定时线程池

优点：支持定时和周期性任务，适用于需要定期执行任务的场景

缺点：如果任务过多，调度和执行可能会产生延迟

线程池用完以后是否需要shutdown（）

以下场景考虑关闭线程池：

**临时使用：**如果线程池是为了执行一组特定任务而创建的，并且之后不需要了，那么需要在任务执行完成后关闭线程池。

**任务频率较低：**如果一组任务执行的频率很低，那么在任务执行完成后也需要关闭线程池。

以下场景不需要关闭线程池：

**全局线程池：**在实际开发中我们一般会定义一些全局线程池，这些线程池为多个业务功能共用，在某个业务执行完成后不能关闭线程池。

**频繁任务处理：**应用程序频繁地处理任务，且这些任务是应用程序正常操作的一部分，通常不需要关闭线程池。

线程池中的线程出现了异常要怎么处理？

通常情况下，线程池中的线程在执行过程中出现了未捕获的异常时，线程会立刻停止，线程池是不会将异常抛给使用者的。如果我们不加以处理，则可能会导致一些问题，所以一般都需要对异常进行处理，方式有如下几种：

**使用try-catch块：**在任务中直径使用try-catch来捕获和处理异常，这是最直接的方式。

**UncaughtExceptionHandler：**实现ThreadFactory接口，我们可以创建一个自定义的线程工厂，在这个工厂里，我们创建自定义的线程，并为这些线程设置一个UncaughtExceptionHandler。该处理器会捕获线程执行过程中未被捕获的异常。

**使用submid()返回Future对象：**使用ExecutorService.submit()提交任务，该方法会返回一个Future对象。我们可以通过Future.get()方法，获取线程在执行过程中的任何异常。这些异常会被封装在ExecutionException中。

重写afterExecute()方法：重写afterExecute()，该方法在每个任务执行完成后都会被调用，无论是正常完成还是异常终止，在该方法中我们就可以获取线程中的异常对象。

线程池是如何实现线程复用的？

ThreadPoolExecutor使用corePoolSize和maximumPoolSize控制核心线程数和最大线程数。初始时，线程会创建核心线程数（corePollSize）的线程来处理任务。当线程被提交到线程池后，线程池会首先尝试使用空闲的核心线程来执行任务，如果没有空闲的核心线程，则任务会被放入任务队列（workQueue）。工作线程会从任务奴队列中获取任务执行，从而避免频繁创建和销毁线程。

那线程是如何实现复用的呢？在ThreadPoolExecutor#runWorker()方法中，工作线程会不断地从任务队列（workQueue）中获取任务，当一个线程执行完成任务后，线程并不会直接退出，而是采用死循环地方式不断从任务队列中获取新地任务执行，只要任务队列中有任务，那么该线程就会一直执行下去。同时，调用它地方式并不是通过Thread#start()的方法，而是直接调用它的run方法，这样把run()方法当作普通方法去调用执行业务逻辑，而不是通过Thread#start()去创建新的线程，从而实现线程复用。

线程复用流程

任务提交：应用程序向线程池提交一个任务。
核心线程检查：线程池检查是否有空闲的核心线程。
- 如果有，则选择一个空闲的核心线程来执行任务。
- 如果没有，则进入下一步。
工作队列检查：将任务放入工作队列中等待执行。
- 如果工作队列已满（对于有界队列），则进入下一步。
- 如果工作队列未满，则等待核心线程从队列中取出任务执行。
非核心线程创建：如果工作队列已满且线程池中的线程数量未达到最大线程数，则创建新的非核心线程来执行任务。
线程回收：非核心线程在执行完任务后，如果在一定时间内没有新任务到达，则会被回收。核心线程则一直保持存活，除非线程池被关闭或配置允许回收核心线程。

线程池的

线程池的拒绝策略

线程池的拒绝策略是指当线程池中的线程数达到其最大容量，并且队列也满了时，线程池如何处理新提交的任务。在Java中，ThreadPoolExecutor提供了以下四种拒绝策略：

AbortPolicy（默认策略）：
- 当任务无法被线程池执行时，会抛出一个RejectedExecutionException异常。
- 这种策略适合于那些不能容忍任务被丢弃或延迟执行的业务场景，因为它会立即通知调用者任务被拒绝，从而可以采取相应的措施，比如增加线程池大小、优化任务执行效率或者通知用户等待。
CallerRunsPolicy：
- 当任务无法被线程池执行时，会直接在调用者线程中运行这个任务。
- 如果调用者线程正在执行一个任务，则会创建一个新线程来执行被拒绝的任务。
- 这种策略适合于那些可以容忍任务在调用者线程中执行的业务场景，它允许任务继续执行，而不会因为线程池资源不足而被丢弃。但需要注意的是，如果调用者线程本身就很忙，或者任务执行时间很长，这可能会导致调用者线程被阻塞，从而影响系统的响应性。
DiscardPolicy：
- 当任务无法被线程池执行时，任务将被丢弃，不抛出异常，也不执行任务。
- 这种策略适用于那些可以丢弃任务而不影响系统整体运行的场景，比如某些日志收集或监控任务。
DiscardOldestPolicy：
- 当任务无法被线程池执行时，线程池会丢弃队列中最旧的任务（即等待时间最长的任务），然后尝试再次提交当前任务。
- 这种策略可以看作是一种折衷方案，它保留了新任务，但丢弃了最不可能在短时间内被执行的任务。

除了以上四种内置的拒绝策略外，还可以根据需要自定义拒绝策略。自定义拒绝策略需要实现RejectedExecutionHandler接口，并实现其rejectedExecution方法。在这个方法中，可以定义自己的任务拒绝处理逻辑。

以上信息主要基于Java中的ThreadPoolExecutor类及其拒绝策略的描述。在实际应用中，应根据具体业务场景和性能要求来选择合适的拒绝策略。

为什么不建议通过Executors构建线程池

Executors是java并发包里提供的一个用于创建java线程池的工具类，它提供了一些工厂方法用于创建常见的线程池，给我们带来了一定程度上的遍历，不推荐的原因有：

1.任务队列没有设置固定容量大小

newFixedThreadPoll()和newSingleThreadExecutor()，它们在创建线程时使用的是无界队列LinkedBlockingQueue。这就意味着当所有线程都在处理任务时，新来的任务会不断地加入到队列中，由于是无界的，所以可以无限制添加直到系统内存耗尽。

2.最大线程数量是Integer.MAX_VALUE

newCachedThreadPool()使用的是一个没有容量的任务队列，提交的任务全部交给线程执行，如果没有空闲的线程，则会创建新线程。所以，如果系统的任务数量非常多，线程池就会创建大量的线程，也会导致系统内存耗尽。

如何判断线程池的任务是否全部执行完

判断线程池的任务是否全部执行完，主要取决于你使用的线程池类型以及你的具体需求。Java中java.util.concurrent包下的ExecutorService接口提供了几种方式来实现这一目标。以下是几种常见的方法：

1. 使用`shutdown()`和`awaitTermination()`方法

当你想停止接收新任务，但希望等待已提交的任务完成后再继续执行时，可以使用shutdown()方法来启动线程的关闭过程，并随后调用awaitTermination()来等待线程池中的所有任务完成。

ExecutorService executor = Executors.newFixedThreadPool(10);  
  
// 提交任务到线程池  
for (int i = 0; i < 100; i++) {  
    final int taskId = i;  
    executor.submit(() -> {  
        // 执行任务  
        System.out.println("Executing task " + taskId);  
    });  
}  
  
// 关闭线程池，不再接受新任务  
executor.shutdown();  
  
try {  
    // 等待所有任务完成，如果所有任务在1分钟内完成，则返回true  
    if (!executor.awaitTermination(1, TimeUnit.MINUTES)) {  
        // 取消正在执行的任务  
        executor.shutdownNow();  
        // 可以在这里处理超时情况  
    }  
} catch (InterruptedException e) {  
    // 当前线程在等待过程中被中断  
    executor.shutdownNow();  
    // 当前线程的中断状态被清除  
    Thread.currentThread().interrupt();  
}  
  
// 此时可以确信所有任务都已完成或已被取消

2. 使用`CountDownLatch`

如果你需要更精确地控制任务完成的时机，或者你想在所有任务完成时执行一些额外的操作，可以使用CountDownLatch。你可以在提交每个任务时递减计数器的值，在所有任务执行完成的地方增加计数器的值。

final CountDownLatch latch = new CountDownLatch(100); // 假设有100个任务  
  
ExecutorService executor = Executors.newFixedThreadPool(10);  
  
for (int i = 0; i < 100; i++) {  
    final int taskId = i;  
    executor.submit(() -> {  
        try {  
            // 执行任务  
            System.out.println("Executing task " + taskId);  
        } finally {  
            latch.countDown(); // 任务完成后递减计数器  
        }  
    });  
}  
  
try {  
    // 等待所有任务完成  
    latch.await();  
} catch (InterruptedException e) {  
    Thread.currentThread().interrupt();  
    // 处理中断情况  
}  
  
// 此时可以确信所有任务都已完成