JAVA线程池

一，介绍

想象一下，你是一个忙碌的领导，手头有一堆任务要完成。你一个人怎么可能同时完成这么多任务呢？于是乎，你决定雇佣一支“Java线程池服务团队”。

这个团队里有很多个“小伙伴”（线程），他们每个人都有各自的技能和专长。当你有新的任务时，你只需要把任务交给团队负责人（线程池）就好了。

团队负责人（线程池）会根据任务的复杂度和优先级，选择合适的小伙伴（线程）来处理任务。有些任务可能很简单，只需要一个小伙伴就能搞定；有些任务可能很复杂，需要几个小伙伴共同协作。

Java线程池是一种用于管理和复用线程的机制，它可以在需要执行任务时，从线程池中获取一个空闲线程来执行任务，而不是每次都创建新的线程。线程池可以提高程序的性能和资源利用率，并且可以控制并发线程的数量，防止系统资源耗尽。

Java提供了java.util.concurrent包中的Executor框架来支持线程池的实现。常用的线程池实现类有以下几种：

1.FixedThreadPool

ExecutorService executor = Executors.newFixedThreadPool(5); // 创建一个固定大小的线程池，最多同时执行5个任务
executor.execute(new MyTask()); // 提交任务
executor.shutdown(); // 关闭线程池

2.CachedThreadPool

ExecutorService executor = Executors.newCachedThreadPool(); // 创建一个缓存线程池 executor.execute(new MyTask()); // 提交任务 executor.shutdown(); // 关闭线程池

3.SingleThreadExecutor

ExecutorService executor = Executors.newSingleThreadExecutor(); // 创建一个单线程线程池 executor.execute(new MyTask()); // 提交任务 executor.shutdown(); // 关闭线程池

4.ScheduledThreadPool

ScheduledExecutorService executor = Executors.newScheduledThreadPool(3); // 创建一个定时任务线程池，最多同时执行3个任务
executor.schedule(new MyTask(), 1, TimeUnit.SECONDS); // 延迟1秒执行任务
executor.scheduleAtFixedRate(new MyTask(), 0, 1, TimeUnit.SECONDS); // 每隔1秒执行任务
executor.shutdown(); // 关闭线程池

以上是一些常用的线程池实现类，通过调用execute()方法或submit()方法可以向线程池提交任务。线程池会自动管理线程的创建、复用和回收，可以通过调整线程池的大小和配置来满足不同的需求。

使用线程池时需要注意合理设置线程池的大小，避免线程过多导致资源浪费，或线程过少导致任务堆积。同时，需要确保提交给线程池的任务是线程安全的，以避免并发访问的问题。

二，线程池参数介绍

线程池的参数可以用来配置线程池的大小、任务队列、线程的生存时间等，以满足不同场景下的需求。下面是线程池的一些常见参数及其介绍：

1.核心线程数（corePoolSize）：

核心线程数是线程池中保持活动状态的线程数量，即使这些线程是空闲的。核心线程会一直存活，除非设置了

allowCoreThreadTimeOut参数为true，则空闲一定时间后会被回收。默认情况下，核心线程数为0。

2.最大线程数（maximumPoolSize）：

最大线程数是线程池中允许的最大线程数量。当任务提交到线程池中，如果核心线程数还未达到上限，会创建新的核心线程来执行任务；如果核心线程数已达到上限，会将任务放入任务队列；如果任务队列已满，且当前线程数小于最大线程数，则会创建新的非核心线程来执行任务。默认情况下，最大线程数为Integer.MAX_VALUE。

3.任务队列（workQueue）：

任务队列用于保存等待执行的任务。线程池根据任务队列的类型和大小来管理待执行的任务。常见的任务队列类型有以下几种：

SynchronousQueue
LinkedBlockingQueue
ArrayBlockingQueue

自定义队列：也可以根据具体需求实现自定义的任务队列。

4.线程存活时间（keepAliveTime）：

线程存活时间指的是当线程池中的线程数量超过核心线程数时，空闲线程的存活时间。超过存活时间后，空闲线程会被回收，直到线程池中的线程数量不超过核心线程数。默认情况下，线程存活时间为0，即空闲线程会立即被回收。

5.时间单位（unit）：

用于指定线程存活时间的单位，可以是纳秒、毫秒、秒等。

6.拒绝策略（rejectedExecutionHandler）：

当线程池和任务队列都已满，无法继续接受新的任务时，拒绝策略定义了如何处理被拒绝的任务。常见的拒绝策略有以下几种：

AbortPolicy

RejectedExecutionException

CallerRunsPolicy
DiscardPolicy
DiscardOldestPolicy

这些参数可以通过ThreadPoolExecutor类的构造方法或者Executors工具类提供的静态方法来创建线程池时进行配置。根据具体的需求，可以调整这些参数以达到最佳的线程池性能和资源利用率。

三，线程池底层原理

线程池的底层原理主要涉及线程的创建、管理和复用，以及任务的调度和执行。以下是线程池的基本底层原理：

1.线程池初始化：

当创建一个线程池时，会初始化一定数量的线程作为核心线程，这些线程会一直存活，除非设置了允许核心线程超时回收。线程池还可以根据需要创建非核心线程，但数量不能超过最大线程数。

2.任务提交：

当有任务提交到线程池时，线程池会根据当前线程数、任务队列状态和拒绝策略来决定任务的处理方式。如果当前线程数小于核心线程数，会创建新的核心线程来执行任务；如果当前线程数达到核心线程数，任务会被放入任务队列等待执行；如果任务队列已满，且当前线程数小于最大线程数，会创建新的非核心线程来执行任务；如果当前线程数达到最大线程数，且任务队列已满，根据拒绝策略来处理任务。

3.任务调度和执行：

线程池会从任务队列中取出待执行的任务，并将任务分配给空闲的线程来执行。线程池通过线程调度算法（如先进先出、优先级等）来决定任务的执行顺序。执行任务时，线程池会调用任务的run()方法来执行具体的业务逻辑。

4.线程复用：

当一个线程执行完任务后，它并不会被立即销毁，而是会继续等待执行新的任务。这样可以避免频繁地创建和销毁线程，提高线程的复用率和性能。

5.线程回收：

线程池中的线程在空闲一定时间后，如果满足一定条件（如线程池大小超过核心线程数、空闲时间超过存活时间等），会被回收销毁，以节省系统资源。

6.异常处理：

线程池会捕获并处理任务执行过程中抛出的异常，可以通过设置异常处理器（Thread.UncaughtExceptionHandler）来自定义异常处理逻辑。

线程池的底层实现一般使用ThreadPoolExecutor类，它是Executor接口的一个具体实现。ThreadPoolExecutor提供了丰富的配置选项，可以通过构造方法或者setXXX()方法来设置线程池的参数。Java提供的Executors工具类也提供了一些静态方法来创建不同类型的线程池，简化了线程池的创建和配置过程。

通过合理地配置线程池的参数，可以有效地管理线程的创建和复用，提高程序的性能和资源利用率。同时，线程池也可以控制并发线程的数量，避免系统资源耗尽和任务堆积的问题。

四，spring boot 整合Java多线程异步/同步讲解与代码demo

下面是一个完整的 Spring Boot 项目结构，在该项目中实现了异步执行和同步执行，并使用了 Java 线程池：

1. 创建一个 Spring Boot 项目，包含以下文件：

```plaintext

- src/main/java/com/example/demo/

- DemoApplication.java

- config/

- AsyncConfiguration.java

- controller/

- MyController.java

- service/

- MyService.java

- task/

- MyTask.java

```

2. 在 `DemoApplication.java` 文件中，作为 Spring Boot 项目的入口类：

package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

3. 在 `AsyncConfiguration.java` 文件中，配置异步线程池：

package com.example.demo.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
@Configuration
@EnableAsync
public class AsyncConfiguration {
    private static final int CORE_POOL_SIZE = 10;
    private static final int MAX_POOL_SIZE = 20;
    private static final int QUEUE_CAPACITY = 200;
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(CORE_POOL_SIZE);
        executor.setMaxPoolSize(MAX_POOL_SIZE);
        executor.setQueueCapacity(QUEUE_CAPACITY);
        executor.initialize();
        return executor;
    }
}

4. 在 `MyController.java` 文件中，创建一个控制器类，用于接收请求并调用服务类：

package com.example.demo.controller;
import com.example.demo.service.MyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api")
public class MyController {
    @Autowired
    private MyService myService;
    @GetMapping("/sync")
    public String syncExecution() {
        myService.syncExecution();
        return "Sync Execution Done!";
    }
    @GetMapping("/async")
    public String asyncExecution() {
        myService.asyncExecution();
        return "Async Execution Started!";
    }
}

5. 在 `MyService.java` 文件中，创建一个服务类，用于处理具体的业务逻辑：

package com.example.demo.service;
import com.example.demo.task.MyTask;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service
public class MyService {
    @Autowired
    private MyTask myTask;
    public void syncExecution() {
        myTask.execute(); // 同步执行任务
    }
    @Async
    public void asyncExecution() {
        myTask.execute(); // 异步执行任务
    }
}

6. 在 `MyTask.java` 文件中，创建一个任务类，具体定义需要执行的任务内容：

package com.example.demo.task;
import org.springframework.stereotype.Component;
@Component
public class MyTask {
    public void execute() {
        // 执行具体的任务逻辑
        try {
            Thread.sleep(2000); // 模拟耗时操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task Executed!");
    }
}

以上就是一个完整的 Spring Boot 项目结构，其中 `AsyncConfiguration.java` 配置了异步线程池，`MyController.java` 是控制器类，接收请求并调用服务类，`MyService.java` 是服务类，处理具体的业务逻辑，`MyTask.java` 是任务类，定义了需要执行的任务内容。在控制器类中，通过调用服务类的方法实现了异步执行和同步执行的功能。

@EnableAsync和@Async注解

`@EnableAsync` 是一个注解，用于启用 Spring 的异步方法支持。当在 Spring Boot 项目中使用 `@EnableAsync` 注解时，Spring 将会自动创建一个线程池，并使用该线程池来执行带有 `@Async` 注解的方法。

`@Async` 是一个方法级别的注解，用于标识一个方法是异步方法。当调用带有 `@Async` 注解的方法时，Spring 将会将该方法的执行委托给异步任务执行器（线程池）进行处理，而不会阻塞当前线程。

下面是对 `@EnableAsync` 和 `@Async` 的详细解释：

1. `@EnableAsync` 注解：

- `@EnableAsync` 注解通常用于配置类上，表示开启异步方法支持。

- 需要将 `@EnableAsync` 注解放置在 Spring Boot 项目的配置类上，以确保 Spring 能够正确地扫描和管理异步方法。

- 启用异步方法支持后，Spring 将会自动创建一个线程池，用于处理异步方法的执行。

2. `@Async` 注解：

- `@Async` 注解通常用于方法上，表示该方法是一个异步方法。

- 在调用带有 `@Async` 注解的方法时，Spring 会将该方法的执行封装到一个独立的线程中，以实现异步执行。

- 异步方法必须返回 `void` 或者 `Future` 对象（用于获取异步结果）。

- 如果异步方法不需要返回结果，可以将返回类型设置为 `void`。

- 如果异步方法需要返回结果，可以将返回类型设置为 `CompletableFuture` 或者 `ListenableFuture`。

通过使用 `@EnableAsync` 和 `@Async` 注解，可以实现在 Spring Boot 项目中使用异步方法来提升系统的并发能力和响应性能。在执行耗时操作时，将其封装成异步方法，可以避免阻塞主线程，提高系统的吞吐量和并发处理能力。

异步和同步的好处和坏处

异步和同步是两种不同的执行方式，它们各有优缺点。下面是异步和同步的好处和坏处的解释：

异步的好处：

1. 提高系统性能：在异步执行中，可以将长时间运行的操作委托给其他线程或进程处理，同时主线程可以继续处理其他任务，从而提高系统的吞吐量和并发处理能力。

2. 提升用户体验：当执行耗时操作时，使用异步方式可以避免阻塞用户界面或用户请求的响应，提升用户体验和流畅度。

3. 资源利用率更高：异步执行可以充分利用系统资源，使得等待某些操作完成期间的其他资源得以利用，提高系统的资源利用效率。

异步的坏处：

1. 代码复杂性增加：异步执行需要进行线程之间的通信和同步控制，可能涉及到回调函数、Future 或 Promise 的使用，较为复杂，增加了代码的难度和维护成本。

2. 可能引起并发问题：异步执行涉及到多线程或多进程的操作，如果没有正确地处理共享数据的访问，可能会导致并发问题，如竞态条件、死锁等。

3. 调试和排错困难：由于异步执行中任务的执行顺序和执行时机是不确定的，当出现问题时，调试和排错会更加困难，需要使用适当的工具和技术。

同步的好处：

1. 代码简单清晰：同步执行按照代码的顺序依次执行，代码结构相对简单，易于理解和维护。

2. 编程模型直观：同步代码更符合人类的思维方式，按照预期的顺序执行，便于编写和调试。

3. 可靠性高：同步执行避免了并发访问共享数据的问题，能够保证数据的一致性和正确性。

同步的坏处：

1. 性能问题：同步执行会阻塞线程或进程的执行，如果某个操作较为耗时，会导致其他操作等待，从而降低系统的响应速度和吞吐量。

2. 用户体验差：由于同步执行可能会阻塞用户界面或用户请求的响应，长时间的等待会导致用户体验不佳，影响用户满意度。

3. 资源利用率低：同步执行时，等待时间未被充分利用，导致系统资源的浪费。

总的来说，异步执行适用于需要提高系统性能、增强用户体验和充分利用系统资源的场景，但会增加代码复杂性和并发问题的风险；同步执行适用于简单明确的业务场景，但可能存在性能问题和用户体验差的情况下。在实际开发中需根据具体场景选择合适的执行方式。

简单总结一下：

Java线程池是一种用于管理和复用线程的机制，可以提高程序的性能和资源利用率，并且可以控制并发线程的数量，防止系统资源耗尽。

常用的线程池实现类有FixedThreadPool、CachedThreadPool、SingleThreadExecutor和ScheduledThreadPool。

线程池的参数可以用来配置线程池的大小、任务队列、线程的生存时间等，以满足不同场景下的需求。

异步和同步是两种不同的执行方式，它们各有优缺点，需要根据具体的场景选择合适的执行方式。在实际开发中可以使用@EnableAsync和@Async注解来实现异步执行。

五，总结

Java线程池是一种多线程处理技术，它允许线程在池中重复使用，从而优化资源利用和提高性能。通过线程池，可以管理和控制线程的数量、生命周期和执行状态，提高应用程序的并发性和响应速度。线程池的主要特点包括：可重用线程、线程数量控制、任务队列、线程超时处理、线程执行状态监控等。在Java中，线程池是通过Executor框架提供的，其中包括ThreadPoolExecutor和ScheduledThreadPoolExecutor等实现类，可以通过这些实现类创建和管理线程池。使用Java线程池可以提高程序的可维护性、性能和健壮性，是开发高并发应用程序的重要技术之一。

JAVA线程池

JAVA线程池

一，介绍

1.FixedThreadPool

2.CachedThreadPool

3.SingleThreadExecutor

4.ScheduledThreadPool

二，线程池参数介绍

1.核心线程数（corePoolSize）：

2.最大线程数（maximumPoolSize）：

3.任务队列（workQueue）：

4.线程存活时间（keepAliveTime）：

5.时间单位（unit）：

6.拒绝策略（rejectedExecutionHandler）：

三，线程池底层原理

1.线程池初始化：

2.任务提交：

3.任务调度和执行：

4.线程复用：

5.线程回收：

6.异常处理：

四，spring boot 整合Java多线程异步/同步讲解与代码demo

下面是一个完整的 Spring Boot 项目结构，在该项目中实现了异步执行和同步执行，并使用了 Java 线程池：

@EnableAsync和@Async注解

异步和同步的好处和坏处

热门文章

最新文章

相关课程

相关电子书

相关实验场景

JAVA线程池

JAVA线程池

一，介绍

1.FixedThreadPool

2.CachedThreadPool

3.SingleThreadExecutor

4.ScheduledThreadPool

二，线程池参数介绍

1.核心线程数（corePoolSize）：

2.最大线程数（maximumPoolSize）：

3.任务队列（workQueue）：

4.线程存活时间（keepAliveTime）：

5.时间单位（unit）：

6.拒绝策略（rejectedExecutionHandler）：

三，线程池底层原理

1.线程池初始化：

2.任务提交：

3.任务调度和执行：

4.线程复用：

5.线程回收：

6.异常处理：

四，spring boot 整合Java多线程 异步/同步讲解与代码demo

下面是一个完整的 Spring Boot 项目结构，在该项目中实现了异步执行和同步执行，并使用了 Java 线程池：

@EnableAsync和@Async注解

异步和同步的好处和坏处

热门文章

最新文章

相关课程

相关电子书

相关实验场景

四，spring boot 整合Java多线程异步/同步讲解与代码demo