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

This article focuses on "how to use Java thread pool", interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor learn how to use Java thread pool.

Catalogue

Thread pool usage scenario?

Java thread pool usage

Summary

Thread pool usage scenario?

Multithreading is often used in java to deal with some business. It is not recommended to create threads simply by inheriting Thread or implementing the Runnable interface, as it is bound to consume resources to create and destroy threads and thread context switching. At the same time, creating too many threads may also lead to the risk of resource exhaustion, so it is more reasonable to introduce thread pool to facilitate the management of thread tasks. The related classes related to thread pool in java are all in the java.util.concurrent package at the beginning of jdk1.5. Several core classes and interfaces involved include: Executor, Executors, ExecutorService, ThreadPoolExecutor, FutureTask, Callable, Runnable and so on.

Java thread pool usage

For resource pool technology, I believe we have been exposed to, such as database connection pool, common c3p0, dbcp, and so on, and threads also have a corresponding pool, called thread pool.

Java provides the Executors class to create a thread pool, such as:

Public static void main (String [] args) {ExecutorService executorService = Executors.newFixedThreadPool (10); Thread thread = new Thread (()-> {System.out.println ("hello world!");}); executorService.execute (thread);}

You can get a thread pool with a specified number of threads through the newFixedThreadPool () method.

Another example is:

Public static void main (String [] args) {ExecutorService executorService = Executors.newSingleThreadExecutor (); Thread thread = new Thread (()-> {System.out.println ("hello world!");}); executorService.execute (thread);}

You can get a thread pool with a thread count of 1 through the newSingleThreadExecutor () method.

And:

Public static void main (String [] args) {ExecutorService executorService = Executors.newCachedThreadPool (); Thread thread = new Thread (()-> {System.out.println ("hello world!");}); executorService.execute (thread);}

Through the newCachedThreadPool () method, you can get a thread pool that creates threads as needed, which creates a corresponding number of threads based on the number of tasks.

We found that we can create a variety of thread pools through the Executors class, but the Alibaba Java development manual does not recommend that we use the Executors class to create threads, but to create them manually:

So how do you create a thread pool manually?

Public static void main (String [] args) {ThreadPoolExecutor executor = new ThreadPoolExecutor (5,10,5L, TimeUnit.SECONDS, new ArrayBlockingQueue (3), Executors.defaultThreadFactory (), new ThreadPoolExecutor.CallerRunsPolicy ()); executor.execute (()-> {System.out.println ("hello world");});}

You can get a thread pool by constructing a ThreadPoolExecutor object, but you need to specify seven parameters, which are as follows:

CorePoolSize: number of core threads

MaximumPoolSize: maximum number of threads

KeepAliveTime: idle time

Unit: idle time unit

WorkQueue: task queue

ThreadFactory: the factory where threads are created

Handler: saturation strategy

The number of core threads represents the core threads in the thread pool, and they will not be recycled under any circumstances, but wait for the arrival of the task. The maximum number of threads is the maximum number of threads that can be created by the thread pool. Idle time means that a non-core thread still has no task to execute after waiting for idle time, and the thread will be recycled. The factory that creates the thread is used to specify the way to create the thread, which is generally available by default. The saturation policy indicates how excess tasks should be handled when the thread pool reaches the maximum number of threads.

To take a simple example, there are now 10 tasks waiting to be executed, because we have five core threads, so the thread pool will first create five threads to execute five of these tasks, and the remaining five tasks will be placed in the task queue. The capacity of the task queue is only 3, so the task queue can only put down 3 tasks, and the remaining 2 tasks cannot be placed in the queue. The thread pool will create two non-core threads to execute them. If the number of threads in the thread pool reaches the maximum number of threads, it will trigger a saturation policy, such as the CallerRunsPolicy policy here, which will directly discard the new task.

At this point, I believe you have a deeper understanding of "how to use Java thread pool". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

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.