Producer consumer model based on thread pool (including blocking queue)

One 、 Thread pool

Two 、 Model implementation

1、 preparation

2、 Create thread

3、PushTask function

4、PopTask function

5、 Thread execution function Routines

3、 ... and 、 Model test

---

One 、 Thread pool

Same as memory pool , Thread pool is also to improve efficiency . A server may receive many requests in a short time , Wait for the request to be received before creating the thread , At this point, you need to create a thread , This will reduce the processing speed .

In response to this situation , We usually create a batch of threads in advance , Reduce the cost of creating and destroying threads in a short time . It's like going to a hot pot restaurant to eat hot pot , The store won't wait for you to come to the slaughterhouse to get the meat , I will definitely prepare the meat first .

Two 、 Model implementation

Now we are going to build such a model , As a producer, the main thread constantly adds tasks to the task queue , The threads in the thread pool are constantly getting tasks from the task queue . Suppose the capacity of the task queue is unlimited .

Just like blocking queues , The key to implementing such a model is still Put on the task PushTask and Take task PopTask, besides , When creating a thread , There is one detail that needs attention

1、 preparation

2、 Create thread

We create at one time 4 Threads , The parameters to be passed to the thread are tentative , For convenience , We don't actively recycle threads here , Instead, choose to separate threads .

  What needs to be noted here is ,pthread_create The third argument to the function , The passed in function must meet

(1) The return value is void*

(2) There is only one input parameter , That's it void*

But actually ,Routines Is defined in the class , Is a member function , The parameter will contain a hidden this The pointer , So from the perspective of compiler, it becomes Routines(ThreadPool<T>* this , void* args), So we add... At the beginning of the function static

Member functions are generally placed in the code area , Member function added static in the future , At this time, it will be placed in the global area , At this time, the parameters are only void*, Will not contain hidden this The pointer  

3、PushTask function

At this time, because the capacity of the task queue has no upper limit , So we don't need to consider the situation that the task queue is full ._task_queue It's a critical resource , We need to use mutexes to protect this critical resource

The initialization and destruction of mutexes are not shown here .

There is another step we need to wait for the implementation PopTask The function will be written later

4、PopTask function

When taking a task , It is necessary to consider the maintenance of critical resources , Also consider the situation that the task queue is empty .

(1) Since it is to maintain critical resources , Then you need to lock and unlock

(2) Considering whether the task queue is empty , When the task queue is empty , It means that the consumer thread cannot continue to fetch tasks , At this point, add the consumer thread to Wait in condition variable , When the producer thread joins the task , Then wake up the consumer thread .

Initialization and destruction of condition variables , It's not shown here .

 PopTask The function is implemented as follows ：

PushTask The complement of function ：

5、 Thread execution function Routines

Now? Routines It is put into the global area , But threads in the thread pool need access Task queue , Therefore, we need to execute function transfer to the thread this The pointer , In this case , Each thread can access class member variables

  Then we get this The pointer , Use a name that To receive this this The pointer

  We can write an empty Task class , It looks like this

  The complete code of the thread execution function is as follows ：

 

3、 ... and 、 Model test

The main function of the test is as follows , The main thread acts as the producer thread every 1s Add a task to the task queue .

  The effect shown here is similar to that of the previous blocking queue