Thread pool overview

---

Thread pool parameters

	 direct new ThreadPoolExecutor() object , And manually specify the corresponding parameters 
     corePoolSize: Number of core threads in thread pool   After the thread pool is created, it will  new Thread() 5 individual 
     maximumPoolSize: Maximum number of threads , The maximum number of threads supported by the thread pool 
     keepAliveTime: Survival time , When the number of threads is greater than the core thread , The lifetime of idle threads  8-5=3
     unit: Units of survival time 
     BlockingQueue<Runnable> workQueue: Blocking queues   When the number of threads exceeds the core thread data , Then new requests will be added to the blocked queue when they arrive 
     new LinkedBlockingQueue<>()  The default queue length is  Integer.MAX  Then this one is too big , So we need to specify the length of the queue 
     threadFactory: Create the factory object of the thread 
     RejectedExecutionHandler handler: The elimination strategy that will be implemented when the number of threads is greater than the maximum number of threads 

ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5
                , 100
                , 10
                , TimeUnit.SECONDS
                , new LinkedBlockingQueue<>(10000)
                , Executors.defaultThreadFactory()
                , new ThreadPoolExecutor.AbortPolicy()
        );

Thread pools execute processes

• First of all, according to the corePoolSIze Create worker threads
• When the concurrency exceeds the number of core threads , Put redundant tasks into task queue
• If the task queue is full , Determine whether the concurrency exceeds the maximum number of threads , If no new thread is created to execute the task ;
• When the task processing is completed , Threads that exceed the number of core threads will be based on TimeUtil, Expired destruction
• If the task cannot be processed after starting a new thread , Redundant tasks perform other operations according to the rejection policy

JDK Several thread pools provided in

1. newCachedThreadPool
   Thread pool with cache , It will be created when thread resources are needed , Note that the maximum number of threads here is Integer.MAX_VALUE
   Thread sleep time is 60s, Over time, it will be destroyed .
   It is generally used to execute asynchronous tasks with a short life cycle

public static ExecutorService newCachedThreadPool() {
    
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

2. newSingleThreadExecutor
   Singleton thread pool , Ensure that the working thread in the thread pool is 1, Serial execution task .
   differ fixedPool, He promised to return Executor No additional threads will be created

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    
   return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>(),
                                threadFactory));
}

3. newScheduledThreadPool
   Thread pool with scheduled tasks , Be able to perform tasks after a certain delay or on a regular basis .

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    
  return new ScheduledThreadPoolExecutor(corePoolSize);
}


// new ScheduledThreadPoolExecute()
//  Create a delay queue 
public ScheduledThreadPoolExecutor(int corePoolSize,
                               ThreadFactory threadFactory) {
    
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue(), threadFactory);
}