Basic concepts of multithreading ： Getting started with multithreading （ One ）
Multi thread basic implementation ： Getting started with multithreading （ Two ）
Multithreading Management ： Multithreading Foundation （ 3、 ... and ）
State transitions between threads ： Multithreading Foundation （ Four ）
Communication between threads ： Multi thread advanced （ 5、 ... and ）
Locking mechanism ： Multi thread advanced （ 6、 ... and ）
Pessimistic lock and optimistic lock 、CAS： Multi thread advanced （ 7、 ... and ）

At present, we talk about multithreading from establishment to use, and then to performance , Creating multiple threads consumes CPU resources , If the thread runs out, destroy , Isn't it a waste of system resources ？ How can we reasonably create and use ？ Next, let's introduce a common tool ---- Thread pool .

1、 Thread pool

1.1 Why use thread pools

• establish / Consuming threads wastes system resources , Using the thread pool, you can reuse the created threads .
• Control the amount of concurrency （ Main cause ）, Prevent server crash .
• You can manage threads in a unified way .

1.2 principle

Executor It is the top-level interface of thread pool , Its implementation class is ThreadPoolExecutor, Let's take a look at its implementation ：

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

• int corePoolSize： The thread pool has a core ⼼ The number of threads is the highest ⼤ value
• int maximumPoolSize： The total number of threads in this thread pool is the highest ⼤ value
• long keepAliveTime：⾮ nucleus ⼼ Thread idle timeout ⻓.
• TimeUnit unit：keepAliveTime The unit of .
• BlockingQueue workQueue： Blocking queues , Maintain the waiting hold ⾏ Of Runnable Mission object .
• ThreadFactory threadFactory： A factory for creating threads
• RejectedExecutionHandler handler： Refuse to deal with the strategy

1.3 ThreadPoolExecutor

Thread pools are the same as threads , It also has its own state and life cycle ;ThreadPoolExecutor Class ⼀ individual volatile int change
The amount runState To represent the state of the thread pool , Respectively RUNNING、SHURDOWN、STOP 、TIDYING 、TERMINATED.

1.4 Multithreaded implementation process

• When the total number of threads < corePoolSize , Whether the thread is idle or not , Will create a new core thread to execute the task （ In order to quickly reach the maximum number of core threads ）;
• When the total number of threads >= corePoolSize , The new task will be put in the waiting queue , If there are idle core threads , Will take tasks from the queue to execute ;（ Embodies the Thread reuse ）
• If the cache queue is full , And the number of bus passes < maximumPoolSize, You need to create a non core thread to execute ;
• If the cache queue is full , Bus number >= maximumPoolSize, Then the rejection strategy will be implemented .

1.5 Four common thread pools

1.5.1 newCachedThreadPool

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

When you need to hold ⾏ Many short-term tasks ,CacheThreadPool The thread is complex ⽤ rate ⽐ a ⾼, Will significantly mention ⾼ performance .⽽ And thread 60s It will be recycled later , It means that even if no task comes in , CacheThreadPool It won't account for ⽤ A lot of resources .

1.5.2 newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
    
 return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
								new LinkedBlockingQueue<Runnable>());
}

As can be seen from the implementation code ,CachedThreadPool Only the number of non core threads can be created ,FixedThreadPool Only the number of core threads can be created .

1.5.3 newSingleThreadExecutor

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

Yes and no ⼀ A nuclear ⼼ Threads （ corePoolSize == maximumPoolSize=1）, send ⽤ 了 LinkedBlockingQueue（ The capacity is very ⼤）, therefore , Does not create ⾮ nucleus ⼼ Threads . All tasks according to First come, first served ⾏ The order of execution ⾏. If this only ⼀ Your thread is not idle , Then the new task will be stored in the task queue ⾥ Waiting for execution ⾏.

1.5.4 newScheduledThreadPool

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize
 return new ScheduledThreadPoolExecutor(corePoolSize);
}
//ScheduledThreadPoolExecutor():
public ScheduledThreadPoolExecutor(int corePoolSize) {
    
 super(corePoolSize, Integer.MAX_VALUE, DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS, new DelayedWorkQueue());
}

establish ⼀ It 's a decision ⻓ Thread pool ,⽀ Regular and periodic task execution ⾏.