Java线程池ThreadPoolExecutor（中）--- 用例及测试

线程池方法展示：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, 
long keepAliveTime, TimeUnit unit, 
BlockingQueue workQueue, 
RejectedExecutionHandler handler)

代码范例：

package tech.summary.demotest.testthreadpool;

import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPool2 {
    
    

  public static void main(String[] args) {
    
    
    // 构造一个线程池
    ThreadPoolExecutor threadPool =
        new ThreadPoolExecutor(8, 8, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2),
            new ThreadPoolExecutor.CallerRunsPolicy());

    for (int i = 1; i <= 11; i++) {
    
    
      try {
    
    
        // 产生一个任务，并将其加入到线程池
        String task = "task@ " + i;
        //System.out.println("put " + task);
        threadPool.execute(new ThreadPoolTask2(task));
      } catch (Exception e) {
    
    
        e.printStackTrace();
      }
    }
  }
}

/**
 * 线程池执行的任务
 */
class ThreadPoolTask2 implements Runnable, Serializable {
    
    
  // 保存任务所需要的数据
  private Object threadPoolTaskData;

  ThreadPoolTask2(Object tasks) {
    
    
    this.threadPoolTaskData = tasks;
  }

  @Override
  public void run() {
    
    
    synchronized (this){
    
    
      try {
    
    
        System.out.println(Thread.currentThread().getName()+"："+threadPoolTaskData);
        //this.wait();
        // //便于观察，等待一段时间
        Thread.sleep(15000);
      } catch (Exception e) {
    
    
        e.printStackTrace();
      }
      threadPoolTaskData = null;
    }
  }
}

当corePoolSize+workQueue.size()<for循环execute的数量时，并且maximumPoolSize<for循环execute的数量时，main线程会出来帮忙

结果示例：

pool-1-thread-1：task@ 1
pool-1-thread-4：task@ 4
pool-1-thread-5：task@ 5
pool-1-thread-3：task@ 3
pool-1-thread-2：task@ 2
pool-1-thread-6：task@ 6
pool-1-thread-7：task@ 7
pool-1-thread-8：task@ 8
main：task@ 11
pool-1-thread-2：task@ 9
pool-1-thread-7：task@ 10

执行过程亲测当一个任务通过execute(Runnable)方法欲添加到线程池时：

如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过handler所指定的策略来处理此任务。

测试补充：

corePoolSize+workQueue.size()可以大于maximumPoolSize
当corePoolSize满时，先填满workQueue，当workQueue满时，再new新线程填满maximumPoolSize
最大线程数：corePoolSize+补充new出来的线程=maximumPoolSize
当执行中的线程空闲时，再从workQueue中逐步释放出任务放入已经生成的空闲的线程中去执行，也就是说workQueue中的任务最慢执行。
当一个线程的任务完成的时候，就会向workQueue的缓存里面取缓存中的任务------poll()，如果超过设定的时间------keepAliveTime还没取到任务，队列就返回null，线程就关闭自己。

Java线程池ThreadPoolExecutor（中）--- 用例及测试

猜你喜欢