Don't you understand the design and principle of thread pool? Break it up and crush it. I'll teach you how to design the thread pool

You have also consulted various materials when learning thread pool , But I feel that the boss wrote very well but not in detail , The detailed design idea is very simple , So my starting point is to let readers clearly understand the whole design idea and design process , We can draw inferences from one example , In the future, the memory pool can also be easily designed ！ Okay , Text begins ~

Thread pool design ideas

What is a thread pool

Let's start with an analogy , A thread pool is like a toolbox , Every time we need to screw in, we have to take a screwdriver out of the toolbox , Sometimes you need to take out one to screw , Sometimes, when there are many screws, more than one person needs to take out more than one to screw , After screwing their own screws, they will put the screwdriver back , Then take it out the next time others use it . Maybe my example is not perfect , But I think I've basically explained thread pool . To put it bluntly, the thread pool is equivalent to

Applied for some resources in advance

That is to say

Threads

, From the thread pool when needed

Take out the thread

To deal with something , After processing, we can

Put the thread back

.

Why do I need thread pools

Let's think about a problem , Why do I need a thread pool ？ If there is no thread pool, what does it look like every time we call the thread ？ Obviously, the first step is to create a thread , Then give the task to the thread , Finally, destroy the thread . So if we use thread pool instead , When the program is running, we will first create a batch of threads , Then it is handed over to the thread pool to manage . When necessary, we take out threads to process tasks , When we don't need it, we recycle it into the thread pool , Does this avoid the time-consuming operation of creating and destroying threads every time . Some people will say that you use thread pool to consume some memory at the beginning , Never release the memory after that , Isn't this a bit wasteful . In fact, this is similar to the concept of space for time , We do take up a little more memory, but this memory is compared with the time we cherish , It's very cost-effective .

The concept of pool is a very common concept of space for time , In addition to the wired process pool, there is also the process pool 、 Memory pool and so on . In fact, their ideas are the same, that is, I first apply for a batch of resources , Then take it with you , Don't put it back . Hear if there's an idea of cloud computing here , They all have the same reason .

How to design thread pool

Now the hard core knowledge is about to begin , Please sit down and help 、 Grab the handrail ~

Without saying , Take a look at the picture above , What does the thread pool we want to design look like ！

【 Article Welfare 】 In addition, Xiaobian also sorted out some C++ Back-end development interview questions , Teaching video , Back end learning roadmap for free , You can add what you need ：

Click to join the learning exchange group ~

  Group file sharing

Xiaobian strongly recommends C++ Back end development free learning address ：

C/C++Linux Server development senior architect /C++ Background development architect ​

Design thinking

We need a thread pool class , So what do you need in the thread pool class ？ Let's have a look

• We need to store the threads we created , So we need a container for threads

• We need a container to store our tasks , Put the task in this container every time

• Because it is a multithreaded read task , So it's essential that we need a lock , Each read task requires locking and unlocking

• We need to judge when to terminate , Therefore, we also need a variable to judge the termination

• In order to avoid polling to determine whether the task container is empty , It's too inefficient , So we use conditional variables here

Let's explain what a conditional variable is . Conditional variable is a synchronization mechanism in concurrent programming , Conditional variables enable threads to block until after waiting for a condition to occur , And go on with it , During this period, the lock obtained before will be released first , It doesn't affect others to take this lock . Therefore, conditional variables are very powerful and efficient .（ Conditional variables and locks will be explained in detail in my multithreading article , This is not the point , So no more details ）

Next, let's study what operations are required in the thread pool ？

• The operation of adding a task to the thread pool , And at this time, it should inform the thread that it can pick up the task to execute

• A loop operation , Constantly waiting for data in the task container to execute , That is, what needs to be done after initialization

• Stop the above loop by changing the termination variable

Okay , So far, the design idea has been clearly written in detail , Next, it's time to see the specific implementation

Implementation of thread pool

Next, let's take a look at how the thread pool class is implemented , The notes are very detailed , I won't say more. Just go straight to the code .

class CThreadMangerPool
{
public:
 CThreadMangerPool(void):is_runing(false){};
 bool init(int threadnum);// Initialization function
 ~CThreadMangerPool(void);
 void Run(void); // Execute function
 void stop(void); // The function used to terminate the loop
 void addTask(ThreadTask* task);// Add the function of the task to the task container
private:
 bool CreateThreads(int threadnum = 5);
 std::vector<std::shared_ptr<std::thread>> threadsPool; // Thread container , To hold threads
 std::list<std::shared_ptr<ThreadTask>> threadTaskList; // Task container , Used to store tasks executed by threads
 std::condition_variable threadPool_cv; // Condition variables,
 std::mutex threadMutex; // The mutex
 //std::vector<std::shared_ptr<CTcpClient>> tcpClients;
 bool is_runing; // Terminate variable
};

Let's focus on several function implementations ~

stay Run Function , We designed a loop , Keep waiting and taking out tasks , If there are no tasks to perform, sleep and wait （ Use the condition variables mentioned earlier to realize ）

Notice that a technique is used here , We use it while To determine whether the data in the task container is empty , It's because of the startling phenomenon similar to the process , There is a false awakening of the conditional variable .（ This is not the point, so I won't talk about it , It will be explained in detail in the multithreading section of my article ）

void CThreadMangerPool::Run(){
 std::shared_ptr<ThreadTask> task; 
 while(true){ // In circulation

 std::unique_lock<std::mutex> guard(threadMutex);// utilize RALL To manage locks , No manual release

 while(threadTaskList.empty()){ //  False awakening of condition variables is prevented here , So there's no need to if Judge
 if (!is_runing)
 break;
 threadPool_cv.wait(guard); // The use of conditional variables
 }
 if (!is_runing) // ditto   It is to judge if it is not started or if stop Functions exit the loop
 break;

 task = threadTaskList.front(); // Take out the task
 threadTaskList.pop_front(); // Take the task out of the container

 if (task == NULL)
 continue;

 task->DoIt(); // Execute task handling functions
 task.reset(); // Reset pointer
 }

}

Next, let's see how the function of adding tasks is implemented

void CThreadMangerPool::addTask(ThreadTask* task){
 std::shared_ptr<ThreadTask> ptr; // Create a smart pointer to the task
 ptr.reset(task);
 {
 std::lock_guard<std::mutex> guard(threadMutex); // It's also used RALL To manage locks , No manual release
 threadTaskList.push_back(ptr); // Add a task... To the task container
 }
 threadPool_cv.notify_all(); // The notification thread is ready to execute , Is the condition that wakes up just sleeping at the condition variable
 
}

Okay , The key functions have been read , Other things that can be easily achieved include

Initialization function

,

Terminate function

wait

Reference material

Recommend a zero sound education C/C++ Free open courses developed in the background , Personally, I think the teacher spoke well , Share with you ：

C/C++ Background development senior architect , The content includes Linux,Nginx,ZeroMQ,MySQL,Redis,fastdfs,MongoDB,ZK, Streaming media ,CDN,P2P,K8S,Docker,TCP/IP, coroutines ,DPDK Etc , Learn now

  original text ：

Break it and crush it. I'll teach you to design thread pool