Academic Databases
Explore Our Semantic Databases
STEM & Tech
Math, Physics, CS & Engineering...
Economics
Macro, Micro, Econometrics...
Business
Management, Marketing, Finance...
Health & Life Sciences
Biology, Medicine, Neuroscience...
Humanities & Social Sciences
Psychology, Law, Philosophy, History...
General Studies
General & interdisciplinary studies...
Explore Topics
Features

Thread Pool In C++: Efficient Multithreading Implementation Guide

Added: 2026-08-11

Deep Dive

Basic C++ multithreading fundamentals, including creating and managing execution threads using 'std::thread'.

Back to Basics: Concurrency - Arthur O'Dwyer - CppCon 2020

Back to Basics: Concurrency - Arthur O'Dwyer - CppCon 2020

112.4K

In C++11 and later, threads are created using the standard library class std::thread. The constructor takes a callable (typically a lambda) that represents the thread's job. When you create a std::thread object, the thread starts executing immediately - there is no separate start() method. Before destroying a std::thread object, you must call join() on it, which blocks the calling thread until the child thread completes its job. This ensures proper cleanup and prevents resource leaks.

Click to watch →

Back to Basics: C++ Concurrency - David Olsen - CppCon 2023

Back to Basics: C++ Concurrency - David Olsen - CppCon 2023

25.1K

std::thread creates new threads by passing callables and arguments to its constructor. The constructor returns immediately after scheduling, enabling asynchronous execution. Parent threads continue running while child threads execute concurrently. To wait for completion, call join(); to detach a thread, call detach(). You must call either before the thread object goes out of scope, or the destructor calls std::terminate(). Thread creation and join are synchronization points: changes in the parent before creation are visible to children, and changes in children are visible to parents after join returns.

Click to watch →

Tutorial Bahasa Pemograman C++ #4

Tutorial Bahasa Pemograman C++ #4

680

Multithreading enables concurrent execution using multiple threads within a process. C++11 introduced <thread> library for thread creation and management. Threads are created using std::thread with callable objects (functions, lambdas). Thread join synchronizes execution by waiting for completion. Parameters can be passed to threads. Lambda functions enable inline anonymous functions. Concurrent execution improves performance on multi-core processors for CPU-bound tasks.

Click to watch →

Introduction to Multithreading in Modern C++: Build Your First App

Introduction to Multithreading in Modern C++: Build Your First App

To create threads in modern C++, you need to include the thread header file. You then create a thread object by specifying the function that the thread should execute. For example: std::thread worker_one(function_one); std::thread worker_two(function_two); This creates two separate threads that will execute their respective functions concurrently.

Click to watch →

C++ std::thread Introduction

C++ std::thread Introduction

9K

Multi-threading enables parallel execution on multi-core processors by dividing tasks into independent units of work. Key concepts include: (1) Threads represent concurrent execution paths, (2) Multi-core CPUs benefit from parallel processing, (3) Divide-and-conquer strategy splits problems into smaller portions, (4) Three essential steps: creating threads, distributing work, and combining results. C++ threads are created using std::thread with function pointers and arguments. Main thread creates child threads that execute concurrently. The join() method synchronizes threads by blocking until completion. Dynamic thread creation uses command-line arguments and vectors for heap-allocated thread objects. Memory management requires explicit deletion for heap-allocated threads. Unsynchronized threads produce interleaved output, demonstrating concurrent execution.

Click to watch →

Deep Dive

Understanding race conditions and mutual exclusion concepts, specifically using 'std::mutex' and 'std::unique_lock' to protect shared data.

C++ Lecture Series --- Concurrency --- Part 3 of N --- Mutexes

C++ Lecture Series --- Concurrency --- Part 3 of N --- Mutexes

3K

A race condition occurs when program outcome depends on relative ordering of operations by multiple threads. The ticket office analogy illustrates this: two people arriving to buy the last ticket produce different outcomes based on arrival order. A data race is the most dangerous type, causing undefined behavior in C++. Deadlock occurs when threads block waiting for resources held by each other. Livelock is similar but threads are actively doing something without making progress. A critical section is code accessing shared resources that must not execute concurrently. Mutual exclusion ensures no two threads execute critical sections simultaneously. A mutex (mutual exclusion) is a synchronization mechanism with acquire and release operations. Only one thread can hold a mutex at a time. Threads block when attempting to acquire a held mutex. The coffee shop analogy: people (threads) need a key (mutex) to use a washroom (shared resource). Attempting to lock an already-held mutex causes deadlock. std::mutex provides lock(), unlock(), try_lock(), and native_handle(). All unlock operations are synchronized with lock operations on the same mutex. std::lock_guard is an RAII class that prevents forgetting to unlock mutexes. The constructor locks the mutex, and the destructor releases it. This ensures mutex release even if exceptions are thrown. The preferred pattern is to use lock_guard instead of explicit lock()/unlock() calls.

Click to watch →

Fall 2024, CSE-4600-62, Chapter 2 Part 2

Fall 2024, CSE-4600-62, Chapter 2 Part 2

181

A critical section is the part of a program that accesses shared resources. Mutual exclusion is the mechanism that ensures only one process can be in its critical section at a time. By enforcing mutual exclusion at the critical section level, race conditions are avoided. Four conditions must be satisfied: mutual exclusion (no two processes in critical sections simultaneously), no assumptions about CPU speeds, no process outside its critical section can block another, and no process should wait forever to enter its critical section. In the spooler example, when process A is in its critical section, process B should be blocked until process A leaves, allowing process B to enter and see the correct updated value of the 'in' variable.

Click to watch →

Concurrency-Mutual Exclusion and Synchronization

Concurrency-Mutual Exclusion and Synchronization

249

Race conditions occur when multiple processes access shared data items, producing unpredictable results dependent on execution order. For example, in an echo procedure, concurrent input/output operations can cause incorrect output. The operating system must address concurrency concerns: tracking processes, allocating/deallocating resources, protecting against interference, ensuring output independence from processing speed, and managing resource competition. Three main control problems emerge: mutual exclusion (ensuring exclusive access to non-shareable resources), deadlock (processes waiting indefinitely for each other's resources), and starvation (processes denied access indefinitely). Proper mutual exclusion requires: single-process critical section access, no interference in non-critical sections, no deadlock/starvation, immediate access when no contention, no assumptions about process speeds, and finite critical section duration.

Click to watch →

Concurrency | OS Theory | C101 | UIU

Concurrency | OS Theory | C101 | UIU

551

Race conditions occur when multiple threads access shared data simultaneously without coordination. The three-step data modification process (read, modify, write) can lead to data inconsistency. Mutual exclusion solves this by ensuring only one thread accesses shared data at a time. Critical sections are code portions accessing shared resources. Mutex implements mutual exclusion by locking resources when threads enter critical sections and unlocking when they exit.

Click to watch →

HSE CS ACOS 2019-2020 Lectures 39

HSE CS ACOS 2019-2020 Lectures 39

251

Race conditions occur when multiple threads simultaneously access shared memory locations, with at least one thread performing a write operation. This leads to incorrect program behavior because the final result depends on the unpredictable order of thread execution. According to POSIX standards, race conditions result in undefined behavior. Simple operations like compound assignments (+=, -=) appear as single operators but actually consist of multiple machine instructions: loading the variable into a register, modifying the value, and storing the result back. When multiple threads execute these operations simultaneously, instructions can interleave unpredictably, causing incorrect results. Critical sections are code fragments that must execute in mutual exclusion, meaning only one thread can execute a critical section at any given time. Correct mutual exclusion mechanisms must satisfy five requirements: mutual exclusion, progress, bounded waiting, no starvation, and low overhead. Semaphores are synchronization primitives consisting of an integer variable with two atomic operations: down (P operation) and up (V operation). The down operation attempts to decrement the semaphore value; if the result would be negative, the calling thread blocks. The up operation increments the semaphore value and wakes one waiting thread. Binary semaphores (mutexes) are optimized for mutual exclusion where only one thread can access a resource at a time. Atomicity means that an operation appears instantaneous to other threads - they cannot observe the operation in an intermediate state.

Click to watch →

Deep Dive

The mechanics of thread synchronization using condition variables ('std::condition_variable') and waiting predicates.

Lecture 3, Unit 2: using condition variables

Lecture 3, Unit 2: using condition variables

28.5K

Condition variables enable threads to wait for specific conditions to become true by requiring three essential components: a logical condition (what the thread needs to wait for), state variables (to track the condition's status), and a predicate (to test if the condition is met); unlike semaphores, condition variables require explicit lock management and use a while loop with cond_wait to ensure threads only proceed when their specific condition is truly satisfied, with signal operations always performed while holding the lock to maintain atomicity between state updates and notifications.

Click to watch →

תכנות מתקדם 1 - תרגול 12 - תומר גיל

תכנות מתקדם 1 - תרגול 12 - תומר גיל

628

Condition variables (std::condition_variable) are synchronization primitives that allow threads to wait for conditions to become true without busy-waiting. The wait() method blocks the calling thread and releases the associated mutex. notify_one() wakes one waiting thread, while notify_all() wakes all waiting threads. This is more efficient than busy-waiting because waiting threads don't consume CPU resources. The producer-consumer problem is a classic use case where one thread produces data and another consumes it, requiring synchronization to ensure the consumer doesn't try to process data that hasn't been produced yet. Condition variables must be used with a mutex to ensure thread-safe access to shared state.

Click to watch →

Multithreading in Cpp [024] - std::condition_variable

Multithreading in Cpp [024] - std::condition_variable

2.2K

std::condition_variable in C++ provides an efficient mechanism for threads to wait until a specific condition becomes true, eliminating the performance overhead of busy-wait loops by allowing threads to sleep until notified. When a thread calls wait() on a condition variable, it atomically releases the associated mutex and blocks until another thread calls notify_one() or notify_all() to wake it. The notify_one() function wakes exactly one waiting thread, while notify_all() wakes all waiting threads. This approach is significantly more efficient than manually checking conditions in a loop because threads only consume CPU resources when they are actively waiting, rather than continuously polling a condition.

Click to watch →

Multithreading in C++20: A Beginner's Guide to Concurrency

Multithreading in C++20: A Beginner's Guide to Concurrency

std::condition_variable avoids busy-waiting by blocking threads until notified. Use with std::unique_lock (not scope_lock) because you need to unlock the mutex while waiting. The wait() function takes the lock and a predicate: it unlocks the mutex, blocks, and when notified, relocks and checks the predicate. The library may call the predicate multiple times. This ensures efficient waiting without consuming CPU time.

Click to watch →

Multithreading in C++ 11 (Eng) by Oleksandr O. Melnychuk

Multithreading in C++ 11 (Eng) by Oleksandr O. Melnychuk

345

Condition variables provide efficient thread synchronization by allowing threads to wait without consuming CPU cycles. A thread waits on a condition variable until another thread signals it (notify_one or notify_all). The waiting thread is blocked until signaled, then rechecks the condition. notify_one() wakes one waiting thread, while notify_all() wakes all waiting threads. This is much more efficient than polling-based approaches because the CPU isn't wasted on threads that have nothing to do.

Click to watch →

Deep Dive

Familiarity with standard template library (STL) containers, lambdas, and functional wrappers like 'std::function' to represent executable tasks.

5. Стандартная библиотека C++: list, map, map, set, function, io, iterators | ООП 2026

5. Стандартная библиотека C++: list, map, map, set, function, io, iterators | ООП 2026

261

C++ standard library provides sequential containers (vector, deque, list) and associative containers (map, multimap, unordered_map, unordered_multiset). Sequential containers store elements in order: vectors offer random access but slow end insertions, deques provide balanced operations at both ends, lists enable constant-time middle insertions/deletions with iterator stability. Associative containers enable key-based access: ordered versions use balanced trees for O(log n) sorted operations, unordered versions use hash tables for average O(1) operations. Key requirements differ: ordered containers need strict weak ordering, unordered containers need equality and hash functions. Set containers store only keys with automatic sorting. std::function provides polymorphic function wrappers for callbacks. Lambda expressions enable inline anonymous functions with capture clauses for variable access, supporting value/reference capture and mutable modification.

Click to watch →

Michael Caisse: Lambda Functions

Michael Caisse: Lambda Functions

2.6K

std::function is a polymorphic wrapper that can hold any callable object including lambdas, function pointers, member function pointers, and functors. It provides a uniform interface for calling different types of callable objects. The syntax uses template parameters for return type and argument types. std::function can capture and store closure objects, making it useful for storing callbacks and algorithms.

Click to watch →

C++ STL: Complete Guide with Examples, Code & Concepts

C++ STL: Complete Guide with Examples, Code & Concepts

315

Container adapters provide specialized behaviors using underlying containers. std::stack implements LIFO (last-in-first-out) with push, pop, top, empty, size. std::queue implements FIFO (first-in-first-out) with push, pop, front, back, empty, size. std::priority_queue implements a max heap with push, pop, top, empty, size. The algorithm library provides ready-to-use functions: non-modifying (for_each, count, find, etc.), modifying (copy, transform, remove, etc.), sorting (sort, stable_sort, nth_element), searching (binary_search, lower_bound, upper_bound), set operations (union, intersection, difference), and permutations (next_permutation, prev_permutation). All use iterators and support function objects or lambdas.

Click to watch →

Introduction to STL | c++ standard template Library | what ? why? how?

Introduction to STL | c++ standard template Library | what ? why? how?

487

STL (Standard Template Library) is a collection of predefined template classes and functions in C++ wrapped in standard header files. Templates are placeholders for data types that enable writing one function that works with multiple types (int, float, char, strings). Templates use angle brackets to specify types and are not processed before compilation. All STL components are under the 'std' namespace, requiring 'std::' prefix or 'using namespace std;'. Understanding templates is essential for grasping STL, as STL implementations rely on template technology.

Click to watch →

Modern C++ Workshop: Simpler C++ with C++11/14 (Part 3)

Modern C++ Workshop: Simpler C++ with C++11/14 (Part 3)

679

C++ provides powerful mechanisms for working with functions as first-class citizens. Functors are classes that overload the function call operator, enabling instance-based function invocation. Lambdas provide concise syntax for creating anonymous function objects, which are internally transformed into functor classes. The std::function template class serves as a universal container for any callable object matching its call signature, including regular functions, lambdas, and other functors. A key distinction is that std::function can store and exchange different callable types, whereas auto-declared lambda variables cannot be reassigned to different lambdas due to type uniqueness. This infrastructure enables flexible algorithm parameterization and functional programming patterns in C++.

Click to watch →

Thread Pool Basics

Benefits & Design

Core Interface

Enqueue & Creation

Task Execution

Real-world Demo

Thread Pool Basics

0:00

Playing Section

1
Explains the concept of a thread pool and its necessity.
2
Uses a hotel waiter analogy to describe waiting threads.
3
Highlights avoiding system overload from excessive threads.

Deep Dive

Asynchronous task management using 'std::future', 'std::promise', and 'std::packaged_task' to retrieve values or exceptions from pooled threads.

std::async In C++ | Create A Task

std::async In C++ | Create A Task

31.9K

In C++, the std::async function creates tasks with three launch policies: std::launch::async (creates a new thread immediately), std::launch::deferred (executes the task lazily when the future's get() method is called, blocking the calling thread), and the default policy (std::launch::async | std::launch::deferred) which lets the operating system decide whether to create a thread or defer based on system load; this allows clean return values from asynchronous operations without manually managing promises.

Click to watch →

10. Углублённое программирование на C/C++. Многопоточность | Технострим

10. Углублённое программирование на C/C++. Многопоточность | Технострим

13.3K

std::async creates threads to execute callables and returns a std::future for result retrieval. Future::get() blocks until completion and retrieves the value, rethrowing any exceptions. Future::wait_for() and wait_until() provide timeout-based waiting. std::promise<T> allows threads to return values, with set_value() and set_exception() methods. This enables clean asynchronous programming patterns where calling code can wait for results or use timeouts.

Click to watch →

C++ Threading #7: Future, Promise and async()

C++ Threading #7: Future, Promise and async()

130.9K

This section covers two key aspects of C++ thread communication. First, it explains the std::async execution policies: std::launch::deferred executes functions in the same thread when .get() is called, while std::launch::async forces a new thread to be created. The default behavior is implementation-defined, so specifying std::launch::async guarantees threading. Second, the section demonstrates bidirectional communication using std::promise and std::future. The parent creates a promise, gets its future, passes it to the child thread, and later sets the value. The child calls .get() to receive it. This enables passing values from parent to child thread at a later time, not at thread creation.

Click to watch →

Multithreading in C++20: A Beginner's Guide to Concurrency

Multithreading in C++20: A Beginner's Guide to Concurrency

When using std::async, always specify std::launch::async as the first argument to ensure the task runs in a separate thread. Omitting this allows the library to choose deferred execution (running in the calling thread when get() or wait() is called), which can produce different results when using synchronization primitives like latches and barriers. Using deferred execution can lead to unexpected behavior in concurrent programs.

Click to watch →

Companies use these C++ Features in Code | MUST KNOW!

Companies use these C++ Features in Code | MUST KNOW!

11.1K

STD future and STD async are C++ 17 features that simplify concurrent programming by providing a clean way to execute long-running tasks in the background while allowing the main thread to continue executing other work. STD async launches a function asynchronously and returns a STD future object, which acts as a placeholder for the result. STD future.get() retrieves the result when it becomes available. This approach eliminates the complexity of manually creating threads, passing reference variables, and using join() or wait() methods. For example, to run a function that calculates a sum after a 2-second delay, you would write 'auto ft = std::async(sum, a, b);' and then call 'ft.get()' to retrieve the result when needed. The main thread can perform other tasks while waiting for the background task to complete.

Click to watch →

Deep Dive

Advanced queue designs, such as implementing lock-free task queues, work-stealing algorithms, or priority task scheduling.

[KAIST CS492C, 2020 Fall] Other lock-free data structures

[KAIST CS492C, 2020 Fall] Other lock-free data structures

711

Work-stealing queues are lock-free data structures that enable efficient parallel task distribution by allowing one thread to push and pop from one end while multiple threads can steal tasks from the other end, achieving better performance than static scheduling by dynamically distributing work across multiple CPUs and preventing idle threads when work is available.

Click to watch →

Sean Parent | Keynote talk at C++ Russia, 2015

Sean Parent | Keynote talk at C++ Russia, 2015

870

Work stealing dispatchers address lock contention by having each thread maintain its own queue. Threads attempt to steal tasks from other queues when idle, reducing global lock contention. The implementation includes try_pop and try_push operations that return false when contention occurs, allowing threads to spin around all queues before parking. This approach achieves performance comparable to mature implementations like Apple's Grand Central Dispatch, demonstrating that sophisticated concurrent patterns can be implemented with relatively simple code.

Click to watch →

Sean Parent: Better Code: Concurrency

Sean Parent: Better Code: Concurrency

7.5K

Work-stealing schedulers improve task distribution by having each thread maintain its own queue. When a thread's queue empties, it attempts to steal tasks from other threads' queues rather than waiting on a central queue. This reduces contention and balances workload. The implementation tries popping locally first, then stealing from other queues, falling back to waiting if necessary. This simple pattern achieves performance within 10% of highly optimized implementations like Apple's Grand Central Dispatch. Lock-free queues provide minimal benefit due to contention patterns.

Click to watch →

Work Stealing as a job assignment method, defined via Julia; used by Threading Building Blocks

Work Stealing as a job assignment method, defined via Julia; used by Threading Building Blocks

123

Work stealing is a hybrid scheduling technique for parallel shared memory computing that combines static and dynamic work assignment. Static assignment distributes work before execution with no synchronization overhead but poor load balancing. Dynamic assignment achieves good load balancing but introduces synchronization overhead. Work stealing gives each worker its own queue while allowing idle workers to steal jobs from others. Implementation uses atomic operations for thread-safe queue access. Workers process their own queue first, then steal from others when finished. This approach minimizes synchronization overhead while achieving good load balancing, making it suitable for fine-grained parallelism with many threads.

Click to watch →

Afinal, que tem de bom na concorrência em Go? - Lucas Caparelli

Afinal, que tem de bom na concorrência em Go? - Lucas Caparelli

212

Work-stealing queues are a scheduling approach where each processor has its own queue of tasks. When a processor's queue is empty, it 'steals' tasks from other processors' queues. This approach improves cache locality (related tasks stay on the same processor) and reduces contention (processors don't compete for a single shared queue). It's more efficient than global queues for concurrent scheduling.

Click to watch →

Deep Dive

Integrating thread pools with modern C++ Coroutines (C++20) and asynchronous I/O frameworks like Boost.Asio for scalable networking.

Markus Klemm "C++20 Coroutines, with Boost ASIO in production: Frightening but awesome"

Markus Klemm "C++20 Coroutines, with Boost ASIO in production: Frightening but awesome"

2.6K

This comprehensive section explains how C++ coroutines work with Boost.Asio for practical asynchronous programming. It covers the three coroutine keywords (`co_await`, `co_yield`, `co_return`), the awaitable return type that stores coroutine state, and how Boost.Asio fills implementation gaps left by the C++ standard. Key topics include coroutine lifetime management with shared pointers, strand synchronization for thread safety, and practical code patterns demonstrating how coroutines transform callback chains into sequential, readable code while maintaining efficient I/O handling.

Click to watch →

Talking Async Ep1: Why C++20 is the Awesomest Language for Network Programming

Talking Async Ep1: Why C++20 is the Awesomest Language for Network Programming

58.2K

C++20 coroutines, combined with Asio's completion token mechanism, enable writing asynchronous network programs that appear synchronous while running efficiently without threads, simplifying complex asynchronous operations like bidirectional data transfer, timeouts, and cancellation through awaitable functions and logical operators.

Click to watch →

Asio and C++20 coroutines, a happy match Raúl Huertas Jungheinrich

Asio and C++20 coroutines, a happy match Raúl Huertas Jungheinrich

1.8K

C++20 coroutines enable efficient asynchronous programming by allowing functions to suspend and resume execution using 'co_await' and 'co_return' keywords, which, when combined with Asio's asynchronous I/O capabilities, transforms complex asynchronous operations into simple, readable code that can handle thousands of concurrent operations with minimal implementation effort.

Click to watch →

Илья Казаков — В Asio за корутинами

Илья Казаков — В Asio за корутинами

2K

Boost ASIO provides coroutine support through awaitable return types and execution contexts (IOContext, ThreadPool, SystemExecutor), enabling developers to write asynchronous code that appears synchronous while running efficiently. Key concepts include using spawn() to start coroutines, completion tokens for lifetime management, and understanding that coroutines can be executed sequentially or in parallel depending on the executor chosen. The library handles complex asynchronous operations through composition of awaitable primitives, with completion handlers and cancellation tokens providing control flow mechanisms.

Click to watch →

C++20: An (Almost) Complete Overview - Marc Gregoire - CppCon 2020

C++20: An (Almost) Complete Overview - Marc Gregoire - CppCon 2020

142.6K

Coroutines are special functions containing await, yield, or co_return keywords. await suspends execution while waiting for asynchronous operations. yield returns a value to the caller and suspends the coroutine, resuming after the yield statement on subsequent calls. co_return terminates the coroutine. Coroutines enable generators, asynchronous I/O, lazy computations, and event-driven applications. While C++20 provides the language machinery for coroutines, the standard library lacks helper classes like generators or async IO support yet. Writing custom coroutines requires advanced knowledge, so existing libraries are recommended for practical use.

Click to watch →

Thread Pool Basics

Benefits & Design

Core Interface

Enqueue & Creation

Task Execution

Real-world Demo

Thread Pool Basics

0:00

Playing Section

1
Explains the concept of a thread pool and its necessity.
2
Uses a hotel waiter analogy to describe waiting threads.
3
Highlights avoiding system overload from excessive threads.

28.4K views020:19@CppNutsOriginal Release: 2024-02-27

A thread pool is a collection of pre-created threads that continuously wait for tasks to execute, providing efficient concurrent processing by reusing threads instead of creating and destroying them repeatedly; the implementation uses a queue to store tasks, a mutex for synchronization, and a condition variable to notify threads when new tasks arrive, allowing multiple tasks to be processed in parallel while controlling the maximum number of concurrent threads based on system capabilities.

[00:00:00]so hello guys this is rup and you're watching CBB video series on C++ and this is about thread pool so I know this is a most AED video so let's do [Music] it so before going further let's try to understand what is thread pool and why do you need that so thread pool is something you will have I mean the name says thread pool you will have pool where you will have many threads it's very simple and those threads will be always running and waiting for you to give them the task it's like uh if you go to hotel and if it is a big hotel you will see like so many waiters are actually waiting for you to order they will be standing in some queue or somewhere and they will come and attend you right so similarly in thread pool also those threads will be simply waiting for your task and the moment you give them the task they will start executing that so your application in such a way that it can spawn many threads at any time okay so because it wants to run those task in parallel so it will have to spawn a thread okay so you cannot just randomly create let's suppose you have 10 tasks 20 tasks maybe thousand tasks available for now you cannot just simply fire 10,000 or th000 threads it will choke up your whole system so that's not the correct way so if you will have a thread pool where you can schedule the task like okay I will assign these task to a thread pool now thread pool's task is to pick the task from the queue and assign it to different different threads so like how many threads it have it will schedule those task to those threads and you have the control to create n number of threads in any thread pool so if your system supports like eight threads simultaneously if it has eight core it will be good ide to have a thread pool which will have eight threads in that and not only that actually if you are creating thread at random time and then once that job is done you are destroying the thread then this creation of the thread and destroying of the thread is like a wastage right if you can somehow create a thread and then use that thread all the time and once your application is terminating or getting closed that time you terminate all those threads so with this way you will not have to create threads again and again and again and you will end up saving so much of time also so there can to be n number of benefits of this thread pool we have just learned about few basic ones so let's now try to understand what you really need to implement thread pool so first I will draw uh a conceptual diagram or whatever diagram I will draw here I don't know what is that called but it will help you to understand the entire thing okay let's see we have so this is threadpool object so when you are creating thread pool let's say this is TP is the class name and then pool pool is the object name and here you will say let's say four threads so inside main function if you're writing something like this it should end up creating something like this I'll tell you what it is so T1 T2 T3 T4 they all are threads they all are continuously running okay I'll just say continuously running there is a loop here they all are running and they all are see they are all trying to access this Q where we will have ta task one task 2 task three and N number of task because it's a q so they all will try to access this queue so that they can get the job and start running those jobs or task but there is this mutex here because this is a single Q between multiple threads we all know that we have to guard it right so we are guarding it with mutex so only one guy is allowed to modify this queue and and how this whole thingy will work let's say T1 is able to get the mutex and T1 took this task one now T1 will have to remove this task from the queue and then only it can execute okay because it cannot start executing if the task is already in the queue it will have to remove the task and then it will start executing that because execution of the task can take maybe quite long time for that we cannot block this Q because other threads can take their job right so they will just quickly take their job and release the mutex this is the thread pool now let's quickly see what interface you need for this thread pool so if this is L here this is pool so you want a mechanism where you can push the job inside the pool so we know that okay pool is created with four threads so we'll see how we'll create these threads in Constructor of the thread pool and we'll destroy all these threads in the destructor of the thread pool so I was talking about pushing the job right so that pushing we will say NQ because it is a q we will say NQ the jobs so you need this mechanism to push the job and here itself the inner part of this NQ would be to signal that okay some task have come wake up now you have to start the execution because they cannot keep on checking some task have come or not otherwise that would be pooling and it will waste so much of resources so I mean CPU resources it will work again and again and check if something have come or not something have come or not no we'll not do like that we'll ask these threads to sleep so that it will not waste so much of resource and the moment we enq something we'll ask we'll send a signal to any one of these threads that you can wake up and start picking the jobs so NQ is done signaling is done signaling is part of the NQ okay and second thing is you need a mutex which will actually guard your Q so you need third point which is Q this will contain all the task and accessing this Q will be guarded with meex and fourth thing is like very implicit but still I will tell you it's a vector of threads you'll have to contain these threads in some vector or container right so this is also required so let's look at the code now and bear with me guys I'll definitely explain you this code so this is the object I was talking about this is thread pool we are creating this object we are telling that how many threads we want we are telling we want four threads these are just some print of messages and this is the job pushing task so see we have this pool here and we are ening meaning we are pushing the job inside the que and this job is in form of Lambda if you don't know what is Lambda functions please go ahead and watch my previous videos and the best way is just search Lambda function with my channel name CBB nerds Lambda function you'll get it so these are kind of a function pointer you are pushing to the que and those threads will pull out these functions and start executing these functions and here I'm printing just thread ID and this count and we'll simulate that task is taking 1 second to complete okay and the moment we are finished pushing those jobs into the queue we will start doing our own stuff like we will not wait for all these things to get completed because we can push thousands and thousands of job for all these four threads and scheduler will actually take care we will not wait for this thread pool to actually finish all those, tasks and then we go ahead no so that's how this is concurrent operation so NQ is done now let's see how the NQ looks like so I told you right we are getting this task here and we are taking those task as R value reference refence I know I have not explained this r value reference maybe I don't know I'm not quite sure but it's like you just try to understand you're sending a function and this is a perfect forwarding this is trying to take that function as it is whatever parameter you have passed there and it will forward to this as it is that's why we are doing all these things now look at the main part we have this lock mutex which is first trying to lock it and then only we are accessing this tasks Q so this is the Q where we are EMP placing this task function what we have sent from there and then we'll just quickly unlock and now this is the point I was telling you right you have to signal to the threads that wake up I have just pushed a task so this condition variable will help you to notify all those threads that okay something have come start executing so this is done we know how to NQ the task let's let's go and see how to actually create the object of thread pool this is fun so you remember you sent four number right so that four number is coming here number of threads so we'll have to create in a loop right like if you are asking for eight threads nine threads 10 threads so that will have to go in a loop in a loop what we are doing we have this workers Vector this Vector is nothing but I'll show you that it will store your threads see this is the worker and it is storing threads in it okay so this is worker so M Place B we are actually creating the thread inside the vector itself and we are telling that attach that thread with this Lambda function so whatever is selected is a thread and it will be pushed back into this Vector from 0 to three meaning four times now let's see what is happening inside these threads and yeah now as you are done executing this whole thing you have have four threads running and let's see what is their state see it will come inside we have this infinite for Loop right and then we will try to acquire the lock and we'll wait here on that lock if we get false from here so this is the condition for conditional weight if you don't know what is conditional weight how it works I have video for that also it is really a GameChanger thing okay so go ahead and watch that also if you don't know this so it will execute this tiny little function this is also lamb it will execute this and check whether I should wait or go ahead and it will decide on whatever it returns so stop is initially false if you see here so this is false and this task. empty thing will return true and we have negation here so this is also false so in the end it will return false remember this we have not enced the task yet we have just created the thread pool only so all the four threads will wait here now let's go to the place where we are enqing the whole thing so I will take you there yeah we started enqing and let's say we pushed this first job now it will come here and we'll try to lock the mutex as all threads are actually sleeping this can be logged and we'll push this first job and unlock the mutex and tell I know four threads are actually waiting for this condition variable I will notify any one of them so it's not our hand which one will get notified but we are telling notify anyone so anyone will get wake up and it will check this condition again because this can be a spurious wake up also which is like a false thing so in that case stop is still false but this guy task. empty is true no so it is false false negation true so this time it will go true here and it will come inside this is false so it will not go here this condition is to terminate the the threads okay I will explain this also in the end so this won't execute because false is I mean stop is false it will go ahead and remove so this is like moving out the front of the task meaning if it is Q you know that Q is always access from the front and stack is always exis from the top so if it is Q then we'll take the front and we'll say move it out basically it will move the content from there to this variable so I have written also this right extract the task from the task list so we are extracting it and then we are saying remove this task from the task list so we have the task available inside this function I mean this variable and we have removed this task from this task list now we'll unlock this and this is where the whole thing is happening we are now executing this task so this task is actually executable that's why we are able to apply this bracket here and we are actually executing the task here and see by the moment we are executing the task it is obviously possible that there are many many many tasks coming let them come I'm ready because I have just released the lock here they can acquire the lock and start doing their job I mean all those different threads will do their job now while I'm running this task because this task can take maybe 5 days 10 days or 15 days or 5 minutes 5 Seconds doesn't matter we are not blocking anything cool right and once you are done you will again go and loop and try to lock this and the whole story will go again and again for this particular thread and for all the threads so now you can imagine right how it is going to work I not just explained this line here let's see even that also so this line will come in the destructor of the threads so let's say okay let's let's go first to the main function let's say you have cued eight jobs and you started doing your own job and then it is hitting this return zero the moment it is going to hit return zero it will try to deallocate this pool object and see what is happening in the destructor you might be missing the joining and stuff right so this is the place where you will actually join all those threads so this is kind of a waiting for those threads to finish so now destruction is happening you will acquire the lock and see now you're telling stop is equal to true and lock is now unlocked you will notify all the threads and then you will join or wait for them to do their job and complete it and then the whole thread pull object will get destroyed now I know you need so many of prior knowledge like what is condition variable how to push threads into the vector and what is actually this this whole Q thingy here because maybe you might not be aware of what is this STD Q here and what is this function they are not big task to actually understand you will Google I mean you will search on YouTube you will get each and everything maybe you will not get this STD function in my channel I mean but if you want to understand hypothetically what it is doing it is telling that I am a q data structure and I will contain function pointers so these are task right are pushing Lambda functions into this task Q so its type has to be somehow function right so that's how you are doing it now let's see how those threads are stopping when this stop is true okay let's see that so let's say every thread was actually doing some job or waiting for something for Simplicity we'll just believe that okay everything was done and they all are waiting for new job let's pick that scenario first so in that case as we have notified all see notify sorry not this one notify all if you remember uh where is that here it is we are saying notify all right so all the threads will get signal and it's like all the threads will get true here because stop is true now this if stop is true yes it is true and task. Mt is true yes there is no task then we'll return so this return is for all the threads because the same function is actually used for all the four threads now it's the time to actually execute it let's execute it and let's try to understand what is happening here so it says thread P created NQ assigned some task so we started assigning the task and you saw that there was a halt here right let me rerun this again and I will quickly put one more enter so these four bunches were actually running at the same time and then these four started running at the same time so if you notice here we have only four threads that's why these four jobs were automatically running at the same time and they all waited for almost 1 seconds because they all are running at the same time and they will simulate the behavior that they all took 1 second at the same time meaning collectively it will be just 1 second only because they all started at the same time and then these threads will start getting executing so don't think that it is written here so it is printing just before it is getting nced here no it is not printed here it is printed when this piece of code is running try to understand this this is the key point of this whole thing you are enqing this function here you are not running this function here you are giving this function to the pool that okay when some thread is available give this function to those threads and those threads will run the this function so these executions are basically from those threads cool right let me change this number of threads let's say we will have two threads in the pool let me quickly compile this and now if we'll run this you'll see two threads are running at the same time see two two two that's it I'll hit enter when they are waiting for 1 second okay then it will make uh a good graphical thing see these these two were running at the same time these two and these two cool right now let's say you might go little crazy or maybe you will say okay now I will have eight threads and 40 jobs so let's say 40 jobs I'll compile this and execute it now just see these these these these these and yeah see all are in the form of 88 jobs running at the same time and see their execution order is not in sequence so they are actually pure synchronous and this is nothing but a thread ID here so if you notice the same thread ID 36B you'll get it here also see this is 36 b0 this is 36 b0 we are reusing these threads to do our job this is the beauty I mean when I learned this it was so beautiful and I was so so happy about it and I just suddenly started feeling that okay I know so much so this is really good I mean it will give you a good feeling I know and these these lines these enters I am putting so that I can give you the perfect simulation because if I won't do that see it will be just one after another see and you'll be confused like which one ran at one time so if I'll run this and I'll hit enter hit enter hit enter enter then it will give you the simulation okay these threads were running at the same time then only I could give the enter Because all will wait for one second cool right so I know I'll sum up this video guys I know this is like very big video I'm so sorry if you guys got to wait a lot but I feel it is worth it so thanks for watching guys I'll see you in the next videos bye-bye take care

Up Next

Multicore Game Development: C++11 Practices

@CppCon

52.7K views•2014-10-23

BitTorrent Protocol Explained: Piece Selection & Peer Choking

@StevenGordonAU

481 views•2013-02-22

HTTP Requests Explained: GET, POST, PUT, DELETE

@codecademy

103.1K views•2021-10-07

Enigma Machine Mechanics: WWII Encryption Explained

@JaredOwen

13.2M views•2021-12-11

Related Study Plans & Knowledge Roadmaps

Structured learning paths in Computer Science

View All Computer Science Topics

computer-science

Building BitTorrent: Go, P2P & Concurrency

01Go Fundamentals & Concurrency

02Networking Foundations & P2P Architecture

03Bencode Parsing & Torrent Metadata

+ 3 more learning modules

Explore Roadmap

computer-science

Actor Models (C++ Concurrency & Lock-Free)

01C++ Multi-Threading Foundations

02Thread Pools and Task Scheduling

03Atomics and Lock-Free Queue Design

+ 3 more learning modules

Explore Roadmap

computer-science

Coding HM Type Inference: Algorithm W & OCaml

01Introduction to Functional Programming & OCaml

02Abstract Syntax Trees & Language Interpreters

03Type Systems & Lambda Calculus

+ 2 more learning modules

Explore Roadmap

computer-science

Building OAuth 2.0: Node.js OIDC Server

01Web & Security Foundations

02Authentication vs. Authorization & JWTs

03The OAuth 2.0 Protocol & Grant Types

+ 3 more learning modules

Explore Roadmap