Thread pool role
- CPU resource isolation
- reduce context switching
- Reduce resource overhead of thread creation/closing
- better concurrency control
- Better lifecycle control
Design considerations
When designing, pay attention to:
- mixed tasks
- task dependent
- starvation deadlock
- slow operation
Precautions when using
thread pool parameters
- core pool size
- maximum pool size
- core pool full
- queue full
- keep-alive time
Task Queue (BlockingQueue)
- Unlimited queue
- LinkedBlockingQueue
newSingleThreadExecutor
newFixedThreadPool
- LinkedBlockingQueue
- limited queue
- ArrayBlockingQueue
- LinkedBlockingQueue(int capacity)
- saturation strategy
setRejectedExecutionHandler
ThreadPoolExecutor.AbortPolicy
- Abort policy (default)
- throw
RejectedExecutionException
- After the caller captures, implement the logic by itself
ThreadPoolExecutor.CallerRunsPolicy
- Don't drop tasks
- do not throw exceptions
- Return the task to the caller thread for execution (synchronous call)
ThreadPoolExecutor.DiscardOldestPolicy
- Abandon the oldest quest
- Select the task that should be performed next
- will try to submit again
- If using a priority queue, discard the element with the highest priority
- Cooperate
SynchronousQueue使用,可以实现任务提交并等待的效果
ThreadPoolExecutor.DiscardPolicy
- abandonment strategy
- give up this mission
- can be
Semaphore
used in combination- Limit task injection rate
- FIFO
- synchronous handoff
- pass directly to other threads
- SynchronousQueue
newCachedThreadPool
thread factory
- Set exception handling
UncaughtExceptionHandler
- set thread name
- priority (not recommended)
- Daemon thread (not recommended)
- add extra counter
- Add extra stats
Executors.privilegedThreadFactory()
- Use the security policy of creating threads, ClassLoader
Not reconfigurable
- Prevent the ExecutorService from being called externally to the setting method, thereby modifying the thread pool configuration
Executors.unconfigurableExecutorService()
thread pool extension point
- ThreadPoolExecutor
beforeExecutor
afterExecutor
terminate
execution strategy
- Perform tasks without caring about results
void execute(Runnable command)
- Execute the task and need to process the result
Future submit(Callable task)
Future submit(Runnable task)
Future submit(Runnable task, T result)
- Execute a batch of tasks, all of which need to be successfully completed
List<Future> invokeAll(Collection<? extends Callable<T>> tasks)
List<Future> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
- Execute a batch of tasks, only one of them needs to complete successfully
T List<Future> invokeAny(Collection<? extends Callable<T>> tasks)
T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
- Execute a batch of tasks and need to process the results one by one
CompletionService
ExecutorCompletionService