Shulou(Shulou.com)06/03 Report--

This article mainly explains "Why to use thread pool", the content of the explanation is simple and clear, easy to learn and understand, now please follow the editor's train of thought slowly in depth, together to study and learn "why to use thread pool" bar!

Here is a piece of code that creates a thread and runs it:

For (int I = 0; I

< 100; i++) { new Thread(() ->

{System.out.println ("run thread- >" + Thread.currentThread () .getName ()); userService.updateUser (....);}) .start ();}

We want to use this way to do async, or improve performance, and then put some time-consuming operations into a new thread to run.

There is no problem with this way of thinking, but there is a problem with this code. What are the problems? Let's take a look at what the problems are.

Resource consumption for creating destruction threads; we use threads for efficiency reasons, but it takes extra time to create these threads, resources, and system resources are also needed for thread destruction.

Cpu resources are limited, the above code creation threads are too many, resulting in some tasks can not be completed immediately, the response time is too long.

Threads cannot be managed, and the uncontrolled creation of threads seems to outweigh the gain for limited resources.

Since we have a problem with using manual thread creation above, is there a solution?

Answer: yes, use thread pools.

Introduction to thread pool

Thread pool (Thread Pool): a technique in which one or more threads are scheduled and reused in a uniform manner, avoiding the overhead of using too many threads.

What are the advantages of thread pools?

Reduce resource consumption. Reduce the consumption caused by thread creation and destruction by reusing created threads.

Improve response speed. When a task arrives, it can be executed without waiting for the thread to be created.

Improve the manageability of threads.

Thread pool usage

JUC (java.util.concurrent) under the rt.jar package in JDK can create thread pools in two ways: ThreadPoolExecutor and Executors, and Executors can create six different thread pool types.

The use of ThreadPoolExecutor

The thread pool usage code is as follows:

Import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class ThreadPoolDemo {private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor (2,10,10L, TimeUnit.SECONDS, new LinkedBlockingQueue (100)) Public static void main (String [] args) {threadPoolExecutor.execute (new Runnable () {@ Override public void run () {System.out.println ("Hello to Mr. Tian");});}}

The results of the above procedures are as follows:

Hello, Mr. Tian.

Core parameter description

There are four construction methods for ThreadPoolExecutor:

You can see that the last constructor has seven construction parameters, in fact, the first three constructors just wrap the last method, and the first three constructors end up calling the last constructor, so let's talk about the last constructor here.

Parameter interpretation

CorePoolSize

The number of core threads in the thread pool. By default, the core thread has been living in the thread pool. If the allowCoreThreadTimeOut property of ThreadPoolExecutor is set to true, if the thread pool remains idle and exceeds the time specified by keepAliveTime, the core thread will be terminated.

MaximumPoolSize

Maximum number of threads, the maximum number of threads that can be created when there are not enough threads.

KeepAliveTime

The idle timeout of the thread pool takes effect by default for non-core threads, and if the idle time exceeds this time, the non-core threads will be reclaimed. If the allowCoreThreadTimeOut of ThreadPoolExecutor is set to true, the core thread will also be reclaimed if it exceeds the idle time.

Unit

Used with keepAliveTime to identify the time unit of the keepAliveTime.

WorkQueue

Task queues in the thread pool, and tasks submitted using the execute () or submit () methods are stored in this queue.

ThreadFactory

Provides a thread factory for creating new threads for the thread pool.

RejectedExecutionHandler

The rejection policy after the thread pool task queue exceeds the maximum value. RejectedExecutionHandler is an interface with only one rejectedExecution method in which you can add event handling in which the task exceeds the maximum value. ThreadPoolExecutor also provides four default reject policies:

DiscardPolicy (): discard the task and do not process it.

DiscardOldestPolicy (): discards the nearest task in the queue and executes the current task.

AbortPolicy (): throws a RejectedExecutionException exception directly (the default).

CallerRunsPolicy (): neither discard the task nor throw an exception, but directly use the main thread to execute the task.

Use cases with all parameters:

Public class ThreadPoolExecutorTest {public static void main (String [] args) throws InterruptedException, ExecutionException {ThreadPoolExecutor threadPool = new ThreadPoolExecutor (1,1,10L, TimeUnit.SECONDS, new LinkedBlockingQueue (2), new MyThreadFactory (), new ThreadPoolExecutor.CallerRunsPolicy ()); threadPool.allowCoreThreadTimeOut (true); for (int I = 0; I

< 10; i++) { threadPool.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } }); } } } class MyThreadFactory implements ThreadFactory { private AtomicInteger count = new AtomicInteger(0); @Override public Thread newThread(Runnable r) { Thread t = new Thread(r); String threadName = "MyThread" + count.addAndGet(1); t.setName(threadName); return t; } } 运行输出： main MyThread1 main MyThread1 MyThread1 .... 这里仅仅是为了演示所有参数自定义，并没有其他用途。 execute() 和 submit()的使用 execute() 和 submit() 都是用来执行线程池的，区别在于 submit() 方法可以接收线程池执行的返回值。 下面分别来看两个方法的具体使用和区别： // 创建线程池 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 10, 10L, TimeUnit.SECONDS, new LinkedBlockingQueue(100)); // execute 使用 threadPoolExecutor.execute(new Runnable() { @Override public void run() { System.out.println("老田您好"); } }); // submit 使用 Future future = threadPoolExecutor.submit(new Callable() { @Override public String call() throws Exception { System.out.println("田先生您好"); return "返回值"; } }); System.out.println(future.get()); 以上程序执行结果如下： 老田您好 田先生您好 返回值 Executors Executors 执行器创建线程池很多基本上都是在 ThreadPoolExecutor 构造方法上进行简单的封装，特殊场景根据需要自行创建。可以把Executors理解成一个工厂类 。Executors可以创建 6 种不同的线程池类型。 下面对这六个方法进行简要的说明： newFixedThreadPool 创建一个数量固定的线程池，超出的任务会在队列中等待空闲的线程，可用于控制程序的最大并发数。 newCacheThreadPool 短时间内处理大量工作的线程池，会根据任务数量产生对应的线程，并试图缓存线程以便重复使用，如果限制 60 秒没被使用，则会被移除缓存。如果现有线程没有可用的，则创建一个新线程并添加到池中，如果有被使用完但是还没销毁的线程，就复用该线程。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。 newScheduledThreadPool 创建一个数量固定的线程池，支持执行定时性或周期性任务。 newWorkStealingPool Java 8 新增创建线程池的方法，创建时如果不设置任何参数，则以当前机器CPU 处理器数作为线程个数，此线程池会并行处理任务，不能保证执行顺序。 newSingleThreadExecutor 创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。 newSingleThreadScheduledExecutor 此线程池就是单线程的 newScheduledThreadPool。 线程池如何关闭? 线程池关闭，可以使用 shutdown() 或 shutdownNow() 方法，它们的区别是： shutdown()：不会立即终止线程池，而是要等所有任务队列中的任务都执行完后才会终止。执行完 shutdown 方法之后，线程池就不会再接受新任务了。 shutdownNow()：执行该方法，线程池的状态立刻变成 STOP 状态，并试图停止所有正在执行的线程，不再处理还在池队列中等待的任务，执行此方法会返回未执行的任务。 下面用代码来模拟 shutdown() 之后，给线程池添加任务，代码如下： import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; public class ThreadPoolExecutorAllArgsTest { public static void main(String[] args) throws InterruptedException, ExecutionException { //创建线程池 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 10L, TimeUnit.SECONDS, new LinkedBlockingQueue(2), new MyThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy()); threadPoolExecutor.allowCoreThreadTimeOut(true); //提交任务 threadPoolExecutor.execute(() ->

{for (int I = 0; I)

< 3; i++) { System.out.println("提交任务" + i); try { Thread.sleep(3000); } catch (InterruptedException e) { System.out.println(e.getMessage()); } } }); threadPoolExecutor.shutdown(); //再次提及任务 threadPoolExecutor.execute(() ->

{System.out.println ("I want to mention tasks again");});}}

The results of the above procedures are as follows:

Submit Task 0 submit Task 1 submit Task 2

As you can see, the new task will not be accepted after shutdown (), but the previous task will be completed.

Interview questions

What are the common methods of interview question 1:ThreadPoolExecutor?

ThreadPoolExecutor has the following common methods:

Submit () / execute (): execute thread pool

Shutdown () / shutdownNow (): terminates the thread pool

IsShutdown (): determines whether a thread is terminated

GetActiveCount (): number of threads running

GetCorePoolSize (): get the number of core threads

GetMaximumPoolSize (): get the maximum number of threads

GetQueue (): gets the task queue in the thread pool

AllowCoreThreadTimeOut (boolean): sets whether core threads are recycled when idle

These methods can be used to terminate thread pool, thread pool monitoring, and so on.

Interview question 2: what's the difference between submit and execute?

Both submit () and execute () are used to execute the thread pool, except that there is no return method for thread pool execution using execute (), while submit () allows you to receive the return value executed by the thread pool using Future.

Talk about the meaning of the core parameters needed for thread pool creation.

ThreadPoolExecutor contains up to the following seven parameters:

CorePoolSize: number of core threads in the thread pool

MaximumPoolSize: maximum number of threads in the thread pool

KeepAliveTime: idle timeout

Unit of unit:keepAliveTime timeout (hours / minutes / seconds, etc.)

WorkQueue: task queue in thread pool

ThreadFactory: provides a thread factory for thread pools to create new threads

RejectedExecutionHandler: reject policy when the thread pool task queue exceeds the maximum

What's the difference between 3:shutdownNow () and shutdown ()?

Both shutdownNow () and shutdown () are used to terminate the thread pool. The difference between them is that using the shutdown () program will not report an error and will not immediately terminate the thread. It will wait for the cache task in the thread pool to be executed before exiting. After executing shutdown (), it cannot add a new task to the thread pool. ShutdownNow () attempts to stop the task immediately, and throws a java.lang.InterruptedException: sleep interrupted exception if there is still a cache task executing in the thread pool.

Interview question 6: have you ever understood how thread pools work?

When there are tasks in the thread pool that need to be executed, the thread pool will judge that if the number of threads does not exceed the number of cores, a new thread pool will be built for task execution. If the number of threads in the thread pool has exceeded the number of core threads, the task will be queued for execution. If the task queue exceeds the maximum number of queues and the thread pool does not reach the maximum number of threads, a new thread will be created to execute the task. If the maximum number of threads is exceeded, the deny execution policy is executed.

Interview question 5: how to set the number of core threads in the thread pool?

"CPU-intensive tasks": for example, a series of tasks that consume a lot of CPU resources, such as encryption and decryption, compression, computing, etc., are pure CPU computing in most scenarios. Try to use a small thread pool, usually the number of CPU cores + 1. Because CPU-intensive tasks make CPU utilization very high, if you turn on too many threads, it will cause CPU to overswitch.

"IO-intensive tasks": for example, tasks such as MySQL database, file reading and writing, and network communication do not consume CPU resources, but IO operations are time-consuming and time-consuming. You can use a slightly larger thread pool, typically the number of 2*CPU cores. The CPU utilization of IO-intensive tasks is not high, so you can let CPU have other threads to handle other tasks while waiting for IO, making full use of CPU time.

In addition: the higher the proportion of average working time of threads, the fewer threads are needed; the higher the proportion of average waiting time of threads, the more threads are needed.

The above are only theoretical values. In actual projects, it is recommended to tune several times in the local or test environment to find a relatively ideal value.

Interview question 7: why do thread pools need to use (blocking) queues?

There are three main points:

Because if the thread is created indefinitely, it may result in excessive memory consumption, resulting in OOM and excessive switching of cpu.

It is more expensive to create a thread pool.

Interview question 8: why should thread pools use blocking queues instead of non-blocking queues?

Blocking queue can ensure that the thread that gets the task is blocked when there is no task in the task queue, which makes the thread enter the wait state and release cpu resources.

When there is a task in the queue, the corresponding thread is awakened to take the message out of the queue for execution.

So that the thread will not always take up cpu resources.

(after executing the task, the thread takes the task out of the task queue again and executes it through a loop. The code snippet is as follows

While (task! = null | | (task = getTask ())! = null) {}).

It is OK not to block the queue, but it is more troublesome to implement, so why not use something that is useful?

Interview question 9: do you know the thread pool status?

By getting the thread pool state, you can determine whether the thread pool is running, whether new tasks can be added, and gracefully close the thread pool.

RUNNING: the initialization state of the thread pool, where you can add tasks to be executed.

SHUTDOWN: the thread pool is waiting to be closed and does not receive new tasks, only those that have already been received.

STOP: the thread pool closes immediately, does not receive new tasks, abandons tasks in the cache queue, and interrupts tasks in progress.

TIDYING: the thread pool collates the state by itself, and calls the terminated () method to clean up the thread pool.

TERMINATED: thread pool termination status.

Interview question 10: do you know the principle of thread reuse in the thread pool?

The thread pool decouples the thread from the task, which is the thread and the task is the task, getting rid of the restriction that a thread must correspond to a task when a thread was created through Thread.

In the thread pool, the same thread can constantly get new tasks from the blocking queue to execute. The core principle is that the thread pool encapsulates Thread. Instead of calling Thread.start () to create a new thread every time the task is executed, each thread is asked to execute a "circular task". In this "circular task", constantly check whether there are any tasks that need to be executed, and if so, execute them directly. That is, the run method in the task is called and the run method is executed as a normal method, in this way the run methods of all tasks are concatenated using only fixed threads.

Thank you for your reading, the above is the content of "Why to use thread pool", after the study of this article, I believe you have a deeper understanding of why to use thread pool, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.