JAVA线程池

 (1)根据xml文件来管理线程池的最大最小线程数
  (2)对线程池通过Timer定期扫描以防止线程未激活;
  (3)通过某一个变量(本程序中是freeThreadCount)来得到空闲线程的数目;
  一、配置xml(listen.xml)是:
  <?xml version="1.0" encoding="UTF-8"?>
   <config>
   <ConsumeThreadPool>
   <minPools>10</minPools> <!--线程池最小线程-->
   <maxPools>100</maxPools> <!--线程池最大线程-->
   <checkThreadPeriod>5</checkThreadPeriod> <!--检查线程池中线程的周期5分钟-->
   </ConsumeThreadPool>
   </config>
  二、对于ConsumeThreadPoolPara的javabean:
  import java.io.*;
  public class ConsumeThreadPoolPara implements Serializable{
   private int minPools;
   private int maxPools;
   private int checkThreadPeriod;
   public int getMinPools(){
   return minPools;
   }
   public int getMaxPools(){
   return maxPools;
   }
   public int getCheckThreadPeriod(){
   return checkThreadPeriod;
   }
   public void setMinPools(int minPools){
   this.minPools = minPools;
   }
   public void setMaxPools(int maxPools){
   this.maxPools = maxPools;
   }
   public void setCheckThreadPeriod(int checkThreadPeriod){
   this.checkThreadPeriod = checkThreadPeriod;
   }
   public String toString(){
   return minPools+" " + maxPools+" "+checkThreadPeriod;
   }
   public ConsumeThreadPoolPara() {
   }
   public static void main(String[] args) {
   ConsumeThreadPoolPara consumeThreadPool1 = new ConsumeThreadPoolPara();
   }
  }
  三、解析xml程序代码(生成ConsumeThreadPoolPara):
  使用jdom解析:
  import org.jdom.*;
  import org.jdom.input.SAXBuilder;
  import java.io.*;
  import java.util.*;
  public class ParseConfig {
   static Hashtable Listens = null;
   static ConnPara connpara = null;
   static ConsumeThreadPoolPara consumeThreadPoolPara = null;
   private static String configxml = "listen.xml";
   static{
   getConsumeThreadPoolPara(); //得到消费的线程池的参数
   }
   /**
   * 装载文档
   * @return 返回根结点
   * @throws JDOMException
   */
   public static Element loadDocument() throws JDOMException{
   SAXBuilder parser = new SAXBuilder(); // 新建立构造器
   try {
   Document document = parser.build(configxml);
   Element root = document.getRootElement();
   return root;
   }catch(JDOMException e){
   logger.error("listen.xml文件格式非法!");
   throw new JDOMException();
   }
   }
   public static ConsumeThreadPoolPara getConsumeThreadPoolPara(){
   if(consumeThreadPoolPara ==null){
   try {
   Element root = loadDocument();
   Element consumeThreadPool = root.getChild("ConsumeThreadPool");
   if (consumeThreadPool != null) { //代表有数据库配置
   consumeThreadPoolPara = new ConsumeThreadPoolPara();
   Element minPools = consumeThreadPool.getChild("minPools");
   consumeThreadPoolPara.setMinPools(Integer.parseInt(minPools.getTextTrim()));
   Element maxPools = consumeThreadPool.getChild("maxPools");
   consumeThreadPoolPara.setMaxPools(Integer.parseInt(maxPools.getTextTrim()));
   Element checkThreadPeriod = consumeThreadPool.getChild("checkThreadPeriod");
   consumeThreadPoolPara.setCheckThreadPeriod(Integer.parseInt(checkThreadPeriod.getTextTrim()));
   }
   }
   catch (JDOMException e) {
   }
   }
   return consumeThreadPoolPara;
   }
  }
  四、线程池源代码:
  import java.util.*;
  /**
  * <p>Title: 线程池</p>
  * <p>Description: 采集消费模块</p>
  * <p>Copyright: Copyright (c) 2004</p>
  * <p>Company: </p>
  * @author 张荣斌
  * @version 1.0
  */
  public class ThreadPool {
   private static int minPools = 10; //最小连接池数目
   private static int maxPools = 100; //最大连接池数目
   private static int checkThreadPeriod = 5; //检查连接池的周期
   ArrayList m_ThreadList; //工作线程列表
   LinkedList m_RunList = null; //工作任务列表
   int totalThread = 0; //总线程数
   static int freeThreadCount = 0; //未被使用的线程数目
   private java.util.Timer timer = null; //定时器
   static Object o = new Object();
   static{ //先初始化线程池的参数
   ConsumeThreadPoolPara consumeThreadPoolPara = ParseConfig.getConsumeThreadPoolPara();
   if(consumeThreadPoolPara!=null){
   minPools = consumeThreadPoolPara.getMinPools();
   maxPools = consumeThreadPoolPara.getMaxPools();
   checkThreadPeriod = consumeThreadPoolPara.getCheckThreadPeriod()*60*1000;
   }
   }
   public void setMinPools(int minPools){
   this.minPools = minPools;
   }
   public void setMaxPools(int maxPools){
   this.maxPools = maxPools;
   }
   public void setCheckThreadPeriod(int checkThreadPeriod){
   this.checkThreadPeriod = checkThreadPeriod;
   }
   public ThreadPool() {
   m_ThreadList=new ArrayList();
   m_RunList=new LinkedList();
   for(int i=0;i<minPools;i++){
   WorkerThread temp=new WorkerThread();
   totalThread = totalThread + 1;
   m_ThreadList.add(temp);
   temp.start();
   try{
   Thread.sleep(100);
   }catch(Exception e){
   }
   }
   timer = new Timer(true); //启动定时器
   timer.schedule(new CheckThreadTask(this),0,checkThreadPeriod);
   }
   /**
   * 当有一个工作来的时候启动线程池的线程
   * 1.当空闲线程数为0的时候,看总线程是否小于最大线程池的数目,就new一个新的线程,否则sleep,直到有空闲线程为止;
   * 2.当空闲线程不为0,则将任务丢给空闲线程去完成
   * @param work
   */
   public synchronized void run(String work)
   {
   if (freeThreadCount == 0) {
   if(totalThread<maxPools){
   WorkerThread temp = new WorkerThread();
   totalThread = totalThread + 1;
   m_ThreadList.add(temp);
   temp.start();
   synchronized(m_RunList){
   m_RunList.add(work);
   m_RunList.notify();
   }
   }else{
   while (freeThreadCount == 0) {
   try {
   Thread.sleep(200);
   }
   catch (InterruptedException e) {
   }
   }
   synchronized(m_RunList){
   m_RunList.add(work);
   m_RunList.notify();
   }
   }
   } else {
   synchronized(m_RunList){
   m_RunList.add(work);
   m_RunList.notify();
   }
   }
   }
   /**
   * 检查所有的线程的有效性
   */
   public synchronized void checkAllThreads() {
   Iterator lThreadIterator = m_ThreadList.iterator();
   while (lThreadIterator.hasNext()) { //逐个遍厉
   WorkerThread lTestThread = (WorkerThread) lThreadIterator.next();
   if (! (lTestThread.isAlive())) { //如果处在非活动状态时
   lTestThread = new WorkerThread(); //重新生成个线程
   lTestThread.start(); //启动
   }
   }
   }
   /**
   * 打印调试信息
   */
   public void printDebugInfo(){
   System.out.println("totalThread="+totalThread);
   System.out.println("m_ThreadList.size()="+m_ThreadList.size());
  }
   /**
   *
   * <p>Title: 工作线程类</p>
   * @author 张荣斌
   * @version 1.0
   */
  class WorkerThread extends Thread{
   boolean running = true;
   String work;
   public void run(){
   while(running){
   synchronized(o){
   freeThreadCount++;
   }
   synchronized(m_RunList){
   while(m_RunList.size() == 0){
   try{
   m_RunList.wait();
   if(!running) return;
   }catch(InterruptedException e){
   }
   }
   synchronized(o){
   freeThreadCount--;
   }
   work = (String)m_RunList.removeLast();
   if(work==null) return;
   }
   // 得到了work 进行工作,这里work可以换成自己的工作类
   }
   }
  }
  }
   /**
   *
   * <p>Title: 定时器调动的任务</p>
   * @author 张荣斌
   * @version 1.0
   */
   class CheckThreadTask extends TimerTask{
   private static boolean isRunning = false;
   private ThreadPool pool;
   public CheckThreadTask(ThreadPool pool){
   this.pool = pool;
   }
   public void run() {
   if (!isRunning) {
   isRunning = true;
   pool.checkAllThreads();
   isRunning = false;
   }
   }
   }

转:http://www.wangchao.net.cn/bbsdetail_42038.html

<think>我们正在讨论Java线程池的使用和原理。根据引用内容,线程池Java中主要通过ThreadPoolExecutor类实现,从JDK5开始内置支持。线程池的好处包括重用线程、控制并发数量、管理线程生命周期等。常见的线程池类型有:FixedThreadPool(固定容量)、CachedThreadPool(缓存)、SingleThreadExecutor(单线程)、ScheduledThreadPool(定时任务)以及通过ThreadPoolExecutor自定义创建。我们将分步骤讲解:1.线程池的核心原理2.创建线程池的五种方式(包括不推荐的原因)3.重点讲解ThreadPoolExecutor及其参数4.线程池的工作机制(任务提交、执行、拒绝策略等)5.使用示例注意:根据引用[3]和[4],ThreadPoolExecutor是构建线程池的核心类,因此我们将重点分析。步骤1:线程池的核心原理线程池通过预先创建一定数量的线程并维护它们,避免频繁创建和销毁线程的开销。当有任务提交时,线程池分配空闲线程执行任务;若没有空闲线程,任务将被放入队列等待;当队列满时,根据设定的拒绝策略处理。步骤2:创建线程池的五种方式(引用[3]和[5])1.newCachedThreadPool:创建一个可缓存的线程池,线程数可无限增加(最大为Integer.MAX_VALUE),空闲线程默认60秒回收。不推荐原因:可能创建过多线程导致OOM。2.newFixedThreadPool:固定大小的线程池,使用无界队列(LinkedBlockingQueue)。不推荐原因:无界队列可能堆积大量任务导致OOM。3.newSingleThreadExecutor:只有一个线程的线程池,同样使用无界队列。不推荐原因同上。4.newScheduledThreadPool:用于定时或周期性任务的线程池。不推荐直接使用的原因是其最大线程数为Integer.MAX_VALUE,可能创建过多线程。5.推荐方式:直接使用ThreadPoolExecutor构造函数创建,可明确指定参数,避免资源耗尽。步骤3:ThreadPoolExecutor的七个参数(引用[3]和[4])构造方法如下:```javapublicThreadPoolExecutor(intcorePoolSize,intmaximumPoolSize,longkeepAliveTime,TimeUnitunit,BlockingQueue<Runnable>workQueue,ThreadFactorythreadFactory,RejectedExecutionHandlerhandler)```1.corePoolSize:核心线程数,即使空闲也不会被回收(除非设置allowCoreThreadTimeOut)2.maximumPoolSize:最大线程数3.keepAliveTime:非核心线程的空闲存活时间4.unit:存活时间单位5.workQueue:任务队列(常用有ArrayBlockingQueue有界队列,LinkedBlockingQueue无界队列,SynchronousQueue同步移交队列)6.threadFactory:线程工厂,用于创建线程7.handler:拒绝策略(当线程池和队列都满时触发)步骤4:线程池的工作机制(任务提交执行流程)1.提交任务后,如果当前线程数小于corePoolSize,则创建新线程执行(即使有空闲线程)。2.如果当前线程数>=corePoolSize,则将任务放入workQueue。3.如果队列已满,且线程数小于maximumPoolSize,则创建新的非核心线程执行。4.如果队列已满且线程数达到maximumPoolSize,则触发拒绝策略。拒绝策略(handler)有四种:-AbortPolicy(默认):抛出RejectedExecutionException-CallerRunsPolicy:由调用线程执行该任务-DiscardPolicy:丢弃任务,不抛异常-DiscardOldestPolicy:丢弃队列最前面的任务,然后重试步骤5:使用示例(以ThreadPoolExecutor为例)下面是一个自定义线程池的示例:```javaimportjava.util.concurrent.*;publicclassThreadPoolExample{publicstaticvoidmain(String[]args){//创建线程池ThreadPoolExecutorexecutor=newThreadPoolExecutor(2,//核心线程数5,//最大线程数60,//空闲线程存活时间TimeUnit.SECONDS,newArrayBlockingQueue<>(10),//有界队列,容量10Executors.defaultThreadFactory(),newThreadPoolExecutor.AbortPolicy());//拒绝策略:直接抛出异常//提交任务for(inti=0;i<15;i++){finalinttaskId=i;executor.execute(()->{System.out.println("Task"+taskId+"isrunningonthread"+Thread.currentThread().getName());try{Thread.sleep(1000);//模拟任务执行}catch(InterruptedExceptione){e.printStackTrace();}});}//关闭线程池executor.shutdown();}}```注意:实际任务数15个,核心线程2个,最大线程5个,队列容量10个。因此前2个任务会创建核心线程执行,接下来的10个任务放入队列,然后第13、14、15个任务会创建非核心线程(共3个非核心线程,总线程数5个)。如果超过15个任务(比如16个),则会触发拒绝策略。最后,关于线程池的关闭,可以使用shutdown()(等待已提交任务完成)或shutdownNow()(尝试中断所有线程,停止任务)。总结:使用线程池时,推荐直接使用ThreadPoolExecutor构造函数,根据实际需求设置参数,避免使用Executors工厂方法可能导致的资源耗尽问题。相关问题:1.线程池中任务队列有哪些类型?各自特点是什么?2.如何合理设置线程池的核心线程数和最大线程数?3.线程池的拒绝策略有哪些?如何自定义拒绝策略?4.如何监控线程池的运行状态?5.线程池中线程是如何创建的?如何自定义线程工厂?</think>### Java线程池使用指南与原理分析 Java线程池通过`java.util.concurrent`包实现,核心类是`ThreadPoolExecutor`。线程池的核心思想是**复用线程**,避免频繁创建销毁线程的开销。线程池中的线程执行完任务后不会销毁,而是回到池中等待新任务[^2]。 --- #### **一、线程池的创建方式** Java提供5种创建线程池的方法(实际都是`ThreadPoolExecutor`的包装): 1. **固定大小线程池**(推荐) ```java ExecutorService fixedPool = Executors.newFixedThreadPool(5); // 固定5个线程 ``` - 特点:核心线程数=最大线程数,使用无界队列`LinkedBlockingQueue` - 风险:任务过多时可能导致OOM(队列无限增长)[^5] 2. **缓存线程池**(不推荐) ```java ExecutorService cachedPool = Executors.newCachedThreadPool(); ``` - 特点:线程数无上限(`Integer.MAX_VALUE`),空闲线程60秒回收 - 风险:高并发时可能创建大量线程导致OOM[^3] 3. **单线程池** ```java ExecutorService singlePool = Executors.newSingleThreadExecutor(); ``` - 特点:仅1个线程,保证任务顺序执行 - 风险:同固定线程池(无界队列问题) 4. **定时任务线程池** ```java ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(3); ``` 5. **推荐做法:手动创建`ThreadPoolExecutor`** ```java ThreadPoolExecutor customPool = new ThreadPoolExecutor( 4, // 核心线程数 10, // 最大线程数 60, // 空闲线程存活时间(秒) TimeUnit.SECONDS, new ArrayBlockingQueue<>(100), // 有界队列(容量100) new ThreadPoolExecutor.AbortPolicy() // 拒绝策略 ); ``` --- #### **二、核心参数详解(7个关键参数)** ```java public ThreadPoolExecutor( int corePoolSize, // 核心线程数(常驻线程) int maximumPoolSize, // 最大线程数 long keepAliveTime, // 非核心线程空闲存活时间 TimeUnit unit, // 时间单位 BlockingQueue<Runnable> workQueue, // 任务队列 ThreadFactory threadFactory, // 线程工厂 RejectedExecutionHandler handler // 拒绝策略 ) ``` 1. **任务队列类型** - `ArrayBlockingQueue`:**有界队列**(推荐),避免OOM - `LinkedBlockingQueue`:**无界队列**(默认) - `SynchronousQueue`:不存储任务,直接移交线程 2. **拒绝策略**(当队列和线程池全满时触发) - `AbortPolicy`(默认):抛出`RejectedExecutionException` - `CallerRunsPolicy`:由调用者线程直接执行任务 - `DiscardPolicy`:静默丢弃任务 - `DiscardOldestPolicy`:丢弃队列最旧的任务 --- #### **三、线程池工作原理** 1. **任务提交流程**: - 当线程数 < `corePoolSize`,**创建新线程**执行任务 - 当线程数 >= `corePoolSize`,任务进入**工作队列** - 当队列已满且线程数 < `maximumPoolSize`,**创建临时线程**执行 - 当队列满且线程数达到`maximumPoolSize`,触发**拒绝策略**[^4] 2. **线程回收机制**: - 核心线程默认不回收(除非设置`allowCoreThreadTimeOut(true)`) - 非核心线程空闲超过`keepAliveTime`后自动销毁 --- #### **四、最佳实践** 1. **参数设置建议**: - CPU密集型任务:核心线程数 = CPU核数 + 1 - IO密集型任务:核心线程数 = 2 * CPU核数 - 使用**有界队列**防止资源耗尽 - 拒绝策略选择`CallerRunsPolicy`保证任务不丢失 2. **代码示例**: ```java ThreadPoolExecutor executor = new ThreadPoolExecutor( Runtime.getRuntime().availableProcessors(), // 核心线程数=CPU核数 Runtime.getRuntime().availableProcessors() * 2, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(500), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy() ); // 提交任务 executor.execute(() -> System.out.println("Task running")); // 优雅关闭 executor.shutdown(); executor.awaitTermination(1, TimeUnit.MINUTES); ``` 3. **注意事项**: - 避免使用`Executors`快捷方法(有OOM风险) - 监控线程池状态(通过`getActiveCount()`等方法) - 务必调用`shutdown()`释放资源 --- #### **五、原理解析** - **线程复用**:通过`Worker`类封装线程,循环从队列获取任务执行[^3] - **任务调度**:核心逻辑在`ThreadPoolExecutor.execute()`方法中 - **资源控制**:通过`BlockingQueue`实现生产者-消费者模型 > 线程池的本质是**资源池化技术**(Pooling),通过复用线程降低系统开销,同时提供流量缓冲和容错能力[^4]。 --- ### 相关问题 1. **为什么`FixedThreadPool`使用无界队列会导致OOM?如何避免?** 2. **线程池中`corePoolSize`和`maximumPoolSize`设置不当会产生什么后果?** 3. **如何实现一个自定义拒绝策略(如记录日志或降级处理)?** 4. **线程池的`shutdown()`和`shutdownNow()`有什么区别?** 5. **如何监控线程池的运行状态(如队列积压、活跃线程数)?** [^1]: ThreadPoolExecutor是Java线程池的核心实现类。 [^2]: JDK5开始内置线程池,线程执行后返回池中复用。 [^3]: 手动创建ThreadPoolExecutor可避免资源耗尽风险。 [^4]: 线程池通过队列缓冲和动态扩缩容管理任务。 [^5]: FixedThreadPool的无界队列可能导致OOM。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值