网站建设项目及费用/销售培训课程一般有哪些

1、ThreadPoolExecutor的参数

ThreadPoolExecutor 是 Java 并发包 java.util.concurrent 中提供的一个灵活的线程池实现，允许开发者精确控制线程池的行为。其构造函数提供了多个参数来定制线程池的工作方式。以下是 ThreadPoolExecutor 的主要构造函数及其参数说明：

构造函数

ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)

参数解释

1. corePoolSize

   • 类型: int
   • 描述: 核心线程数，即线程池中保持的最小线程数量，即使这些线程处于空闲状态也不会被回收（除非设置了允许核心线程超时）。

2. maximumPoolSize

   • 类型: int
   • 描述: 线程池中允许的最大线程数。当任务队列满了，并且当前线程数少于最大线程数时，会创建新的线程来执行任务。

3. keepAliveTime

   • 类型: long
   • 描述: 当线程数超过核心线程数时，多余的空闲线程在终止前等待新任务的最长时间。如果设置为0，则表示多余的空闲线程会被立即终止。

4. unit

   • 类型: TimeUnit
   • 描述: 第三个参数 keepAliveTime 的时间单位，可以是纳秒、微秒、毫秒、秒等。

5. workQueue

   • 类型: BlockingQueue<Runnable>
   • 描述: 用于保存等待执行的任务的阻塞队列。常见的实现包括 SynchronousQueue, LinkedBlockingQueue, 和 ArrayBlockingQueue 等。

6. threadFactory

   • 类型: ThreadFactory
   • 描述: 用于创建新线程的工厂。通过自定义 ThreadFactory 可以为线程池中的线程设置名称、优先级等属性。默认情况下使用 Executors.defaultThreadFactory()。

7. handler

   • 类型: RejectedExecutionHandler
   • 描述: 当线程池和任务队列都满了之后，新的任务将由该处理器处理。常见的策略有：
     • AbortPolicy: 抛出 RejectedExecutionException 异常。
     • CallerRunsPolicy: 直接在调用者线程运行任务。
     • DiscardPolicy: 不处理新来的任务，直接丢弃掉。
     • DiscardOldestPolicy: 丢弃队列里最近的一个任务，并尝试重新提交新任务。

---

2、线程池为什么建议使用 ThreadPoolExecutor 创建，而非 Executors？

• FixedThreadPool 和 SingleThreadPool 允许请求队列长度为
  Integer.MAX_VALUE，可能会堆积大量请求，可能会导致内存溢出；
• CachedThreadPool 和 ScheduledThreadPool 允许创建线程数量为
  Integer.MAX_VALUE，创建大量线程，可能会导致内存溢出。

3、有一个公用线程池处理各种类型的任务，如何限制某一类型的任务同一时间最多只有4个同时执行

如果你希望将 “特定类型任务”限制并发数为4，并且统一由一个公用线程池调度执行这些任务，那么就需要结合：

1. 一个全局公用线程池（比如 TaskExecutor）；
2. 一个用于控制并发数量的 Semaphore。

---

✅ 完整示例：配置线程池 + 使用 Semaphore 控制并发

🧩 步骤一：配置自定义线程池（Spring Boot）

你可以通过配置类创建一个自定义线程池，作为所有异步任务的默认执行器。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;import java.util.concurrent.Executor;@Configuration
public class ExecutorConfig {@Bean(name = "commonTaskExecutor")public TaskExecutor commonTaskExecutor() {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();executor.setCorePoolSize(10);executor.setMaxPoolSize(20);executor.setQueueCapacity(100);executor.setThreadNamePrefix("Common-Executor-");executor.initialize();return executor;}
}

---

🧩 步骤二：配置 Semaphore（控制特定任务的最大并发数）

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import java.util.concurrent.Semaphore;@Configuration
public class SemaphoreConfig {@Bean(name = "specificTaskSemaphore")public Semaphore specificTaskSemaphore() {// 允许最多4个任务同时执行return new Semaphore(4);}
}

---

🧩 步骤三：编写服务类，提交任务到线程池并用信号量控制并发

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.task.TaskExecutor;
import org.springframework.stereotype.Service;import java.util.concurrent.Semaphore;@Service
public class TaskService {private final TaskExecutor taskExecutor;private final Semaphore semaphore;@Autowiredpublic TaskService(TaskExecutor taskExecutor, Semaphore semaphore) {this.taskExecutor = taskExecutor;this.semaphore = semaphore;}public void submitSpecificTask(Runnable task) {taskExecutor.execute(() -> {try {semaphore.acquire();  // 获取许可task.run();           // 执行任务} catch (InterruptedException e) {Thread.currentThread().interrupt(); // 恢复中断状态throw new RuntimeException("任务被中断", e);} finally {semaphore.release();  // 释放许可}});}
}

---

🧩 步骤四：在 Controller 中调用服务方法

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;@RestController
public class TaskController {private final TaskService taskService;public TaskController(TaskService taskService) {this.taskService = taskService;}@GetMapping("/run-task")public String runTask() {taskService.submitSpecificTask(() -> {System.out.println("开始执行任务：" + Thread.currentThread().getName());try {Thread.sleep(3000); // 模拟耗时操作} catch (InterruptedException e) {Thread.currentThread().interrupt();}System.out.println("结束执行任务：" + Thread.currentThread().getName());});return "任务已提交";}
}

---

✅ 总结：为什么需要线程池 + 信号量配合？

组件	作用
TaskExecutor 线程池	负责异步、并发地处理多个任务
Semaphore	控制某一类任务的最大并发数，比如最多只能有4个在运行

这样设计的好处是：

• 资源隔离：不是每个任务都单独开线程；
• 并发控制：能精确控制某种任务的并发上限；
• 可扩展性：可以轻松调整线程池大小和信号量值；
• 兼容 Spring 异步机制：便于后续集成 @Async 注解等高级功能。

---