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

In this article, the editor introduces "how to create Java thread pool" in detail, the content is detailed, the steps are clear, and the details are handled properly. I hope this article "how to create Java thread pool" can help you solve your puzzles. let's learn new knowledge together.

Benefits of thread pool

The reuse of threads can be achieved to avoid recreating and destroying threads. Creating and destroying threads are expensive for CPU.

You can limit the maximum number of threads that can be created, and you can dynamically adjust thread pool parameters according to your machine performance to improve application performance.

Provide timing execution, concurrent number control and other functions.

Uniformly manage threads.

Five ways to create a thread pool

1: cache thread pool (not recommended)

2: fixed capacity thread pool (not recommended)

3: single thread pool (not recommended)

4: scheduled task thread pool (not recommended)

5: create a thread pool through the ThreadPoolExecutor constructor (highly recommended by Alibaba's development manual)

The first four ways to create a thread pool are created through the static method of Executors.

Cache thread pool CachedThreadPool ExecutorService executorService = Executors.newCachedThreadPool (); for (int I = 0; I

< 10; i++) { final int finalI = i; executorService.execute(new Runnable() { public void run() { System.out.println(Thread.currentThread().getName()+"run>

"+ finalI);}});}

Why is the cache thread pool not recommended?

Source code analysis

Public static ExecutorService newCachedThreadPool () {return new ThreadPoolExecutor (0, 2147483647, 60L, TimeUnit.SECONDS, new SynchronousQueue ());} public ThreadPoolExecutor (int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue) {this (corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory (), defaultHandler);}

From the above two code snippets, we can see that the maximumPoolSize of CachedThreadPool is 2147483647 of the maximum Integer, which means that threads can be created indefinitely, which requires memory, which will cause memory overflow, and ordinary machines do not use so much memory to create so many threads for it.

Fixed capacity thread pool FixedThreadPool

NewFixedThreadPool (int num), num is the number of fixed threads that we want to specify

ExecutorService executorService = Executors.newFixedThreadPool (5); for (int I = 0; I

< 10; i++) { final int finalI = i; executorService.execute(new Runnable() { public void run() { System.out.println(Thread.currentThread().getName()+"run>

"+ finalI);}});}

Output:

Pool-1-thread-5run > 4

Pool-1-thread-4run > 3

Pool-1-thread-5run > 5

Pool-1-thread-3run > 2

Pool-1-thread-3run > 8

Pool-1-thread-3run > 9

Pool-1-thread-2run > 1

Pool-1-thread-1run > 0

Pool-1-thread-5run > 7

Pool-1-thread-4run > 6

You can see the reuse of threads.

Why is FixedThreadPool a fixed thread pool?

Source code analysis

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

From this source code, you can see that the number of core threads (corePoolSize) and the maximum number of threads (maximumPoolSize) are both nThreads, because only in this way, the thread pool will not be expanded and the number of threads will be fixed.

Single thread pool SingleThreadExecutor ExecutorService executorService = Executors.newSingleThreadExecutor (); for (int I = 0; I

< 10; i++) { final int finalI = i; executorService.execute(new Runnable() { public void run() { System.out.println(Thread.currentThread().getName()+"run>

"+ finalI);}});}

Why does SingleThreadExecutor contain only one thread?

Source code analysis

Public static ExecutorService newSingleThreadExecutor () {return new Executors.FinalizableDelegatedExecutorService (new ThreadPoolExecutor (1,1,0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue ();}

From this source code, you can see that the number of core threads (corePoolSize) and the maximum number of threads (maximumPoolSize) are both 1, so it contains only one thread.

Timed task thread pool ScheduledThreadPool int initDelay=10; / / initialization delay int period=1;// after initialization delay ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool (10); scheduledExecutorService.scheduleAtFixedRate (new Runnable () {@ Override public void run () {System.out.println (Thread.currentThread (). GetName () + "run >")) }, initDelay,period, TimeUnit.SECONDS)

The effect of this code is to wait 10 seconds after the program runs, then output the results for the first time, and then output the results every 1 second.

Why is ScheduledThreadPool not recommended?

Source code analysis

Public ScheduledThreadPoolExecutor (int corePoolSize) {super (corePoolSize, 2147483647, 10L, TimeUnit.MILLISECONDS, new ScheduledThreadPoolExecutor.DelayedWorkQueue ());}

It can be seen that the maximum number of threads (maximumPoolSize) of ScheduledThreadPool is 2147483647 of Integer, which means that threads can be created indefinitely, which requires memory, which will cause memory overflow, and ordinary machines do not use so much memory to create so many threads for it.

ThreadPoolExecutor create thread pool (highly recommended) ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor (10,20,2L, TimeUnit.SECONDS, new ArrayBlockingQueue (5), Executors.defaultThreadFactory (), new ThreadPoolExecutor.AbortPolicy ()); for (int I = 0; I

< 12; i++) { final int finalI = i; threadPoolExecutor.execute(new Runnable() { public void run() { System.out.println(Thread.currentThread().getName()+"run>

"+ finalI);}});} public ThreadPoolExecutor (int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {} with seven parameters of} ThreadPoolExecutor

CorePoolSize: number of core threads. Once these threads are created, they will not be destroyed and will always exist. By default, there are no threads in the thread pool. When a task arrives, a thread is created through ThreadFactory and exists all the time.

MaximumPoolSize: maximum number of threads. Number of non-core threads = maximumPoolSize-corePoolSize. The number of non-core threads is actually the number of threads that can be expanded and may be destroyed.

KeepAliveTime: idle survival time of non-core threads. When the number of non-core threads generated by capacity expansion is still idle after keepAliveTime, these non-core threads are destroyed.

The unit of time of unit:keepAliveTime, for example: seconds

WorkQueue: waiting area. When a > corePoolSize task comes, the task is stored in the blocking queue of workQueue, waiting for other threads to process it.

ThreadFactory: thread factory. A way to create threads.

Handler: reject policy. When > the maximum number of threads + the capacity of workQueue, the reject policy will be executed.

WorkQueue

ArrayBlockingQueue: bounded blocking queue. The queue has a size limit, and when the capacity is exceeded, the expansion or rejection policy will be triggered.

Public ArrayBlockingQueue (int capacity) {this (capacity, false);}

LinkedBlockingQueue: unbounded blocking queues, queues with no size limit, may cause memory overflows.

Public LinkedBlockingQueue () {this (2147483647);} handler

AbortPolicy: throw an exception directly

Public static class AbortPolicy implements RejectedExecutionHandler {public AbortPolicy () {} public void rejectedExecution (Runnable r, ThreadPoolExecutor e) {throw new RejectedExecutionException ("Task" + r.toString () + "rejected from" + e.toString ());}

DiscardPolicy: do nothing. Silently discard the task

Public static class DiscardPolicy implements RejectedExecutionHandler {public DiscardPolicy () {} public void rejectedExecution (Runnable r, ThreadPoolExecutor e) {}}

DiscardOldestPolicy: lose the task with the longest existence

Public static class DiscardOldestPolicy implements RejectedExecutionHandler {public DiscardOldestPolicy () {} public void rejectedExecution (Runnable r, ThreadPoolExecutor e) {if (! e.isShutdown ()) {e.getQueue () .poll (); e.execute (r);}

CallerRunsPolicy: let the thread submitting the task handle the task

Public static class CallerRunsPolicy implements RejectedExecutionHandler {public CallerRunsPolicy () {} public void rejectedExecution (Runnable r, ThreadPoolExecutor e) {if (! e.isShutdown ()) {r.run ();}

ThreadFactory

ThreadFactory threadFactory = Executors.defaultThreadFactory (); threadFactory.newThread (new Runnable () {@ Override public void run () {System.out.println ("threadFactory");}}) .start (); how to trigger the rejection policy and thread pool expansion? ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor (10,20,2L, TimeUnit.SECONDS, new ArrayBlockingQueue (5), Executors.defaultThreadFactory (), new ThreadPoolExecutor.AbortPolicy ()); for (int I = 0; I

< 26; i++) { //并发数26 final int finalI = i; threadPoolExecutor.execute(new Runnable() { public void run() { System.out.println(Thread.currentThread().getName()+"run>

"+ finalI);}}) } / * * the number of core threads = 10, the maximum number of threads = 20, so the number of scalable threads = 20-10 * the size of BlockingQueue is 5, so the size of the waiting area is 5, that is, when the number of concurrent core threads + the size of the blocking queue * for this code, if there are 26 concurrency, 10 concurrency will be handled by the core thread and 5 will be in the waiting area The remaining 11 will trigger capacity expansion because the waiting area is full * because there can be a maximum of 10 capacity expansion, but here it is 11, so the rejection policy will be triggered * /

Why does this code trigger a reject policy?

For this code, if there are 26 concurrency, 10 concurrency will be handled by the core thread, 5 will be in the waiting area, and the remaining 11 will trigger expansion because the waiting area is full. However, because a maximum of 10 concurrency can be expanded here, there are 11 concurrency, so the rejection policy will be triggered.

How to trigger capacity expansion

Trigger capacity expansion: number of concurrency > number of core threads (corePoolSize) + size of blocking queue (workQueue)

Use Java to handwrite a thread pool

After reading this, the article "how to create Java Thread Pool" has been introduced. If you want to master the knowledge points of this article, you still need to practice and use it yourself. If you want to know more about the article, please follow the industry information channel.

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.