Thread pool

In computer programming, a thread pool is a software design pattern for achieving concurrency of execution in a computer program. Often also called a replicated workers or worker-crew model,[1] a thread pool maintains multiple threads waiting for tasks to be allocated for concurrent execution by the supervising program. By maintaining a pool of threads, the model increases performance and avoids latency in execution due to frequent creation and destruction of threads for short-lived tasks.[2] The number of available threads is tuned to the computing resources available to the program, such as a parallel task queue after completion of execution.

A sample thread pool (green boxes) with waiting tasks (blue) and completed tasks (yellow)

Performance

The size of a thread pool is the number of threads kept in reserve for executing tasks. It is usually a tunable parameter of the application, adjusted to optimize program performance.[3] Deciding the optimal thread pool size is crucial to optimize performance. Hyperbola-based Thread-pool Analysis (HTA) technique has been suggested in order to determine optimal thread pool size for cloud-based indexing process based upon available workload and bandwidth.[4]

One benefit of a thread pool over creating a new thread for each task is that thread creation and destruction overhead is restricted to the initial creation of the pool, which may result in better performance and better system stability. Creating and destroying a thread and its associated resources can be an expensive process in terms of time. An excessive number of threads in reserve, however, wastes memory, and context-switching between the runnable threads invokes performance penalties. A socket connection to another network host, which might take many CPU cycles to drop and re-establish, can be maintained more efficiently by associating it with a thread that lives over the course of more than one network transaction.

Using a thread pool may be useful even putting aside thread startup time. There are implementations of thread pools that make it trivial to queue up work, control concurrency and sync threads at a higher level than can be done easily when manually managing threads[5][6]. In these cases the performance benefits of use may be secondary.

Typically, a thread pool executes on a single computer. However, thread pools are conceptually related to server farms in which a master process, which might be a thread pool itself, distributes tasks to worker processes on different computers, in order to increase the overall throughput. Embarrassingly parallel problems are highly amenable to this approach.

The number of threads may be dynamically adjusted during the lifetime of an application based on the number of waiting tasks. For example, a web server can add threads if numerous web page requests come in and can remove threads when those requests taper down. The cost of having a larger thread pool is increased resource usage. The algorithm used to determine when to create or destroy threads affects the overall performance:

  • Creating too many threads wastes resources and costs time creating the unused threads.
  • Destroying too many threads requires more time later when creating them again.
  • Creating threads too slowly might result in poor client performance (long wait times).
  • Destroying threads too slowly may starve other processes of resources.
gollark: There are mods for resource sharing between local ground bases, I think.
gollark: Just harvest 5 times its mass to use in mass drivers.
gollark: Gilly should be small enough to spin round reasonably well, especially since resources on planets are infinite.
gollark: Though with enough boosters it could just spin the *planet* instead...
gollark: Er, vacuum, not air.

See also

References
  1. Garg, Rajat P. & Sharapov, Ilya Techniques for Optimizing Applications - High Performance Computing Prentice-Hall 2002, p. 394
  2. Holub, Allen (2000). Taming Java Threads. Apress. p. 209.
  3. Yibei Ling; Tracy Mullen; Xiaola Lin (April 2000). "Analysis of optimal thread pool size". ACM SIGOPS Operating Systems Review. 34 (2): 42–55. doi:10.1145/346152.346320.
  4. Harshit Gujral; Abhinav Sharma; Sangeeta Mittal (August 2018). "Determination of Optimal Thread Pool for Cloud Based Concurrent Enhanced No-Escape Search". 2018 Eleventh International Conference on Contemporary Computing (IC3). pp. 1–6. doi:10.1109/IC3.2018.8530645. ISBN 978-1-5386-6834-4.
  5. "QThreadPool Class | Qt Core 5.13.1".
  6. "GitHub - vit-vit/CTPL: Modern and efficient C++ Thread Pool Library". 2019-09-24.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.