Transferred from: http://blog.csdn.net/lmh12506/article/details/7753952
Some time ago on GitHub opened a library, ready to implement their own thread pool, because the change of work, has not been achieved, refer to this article is ready to start to achieve.
When do I need to create a thread pool? Simply put, if an application needs to create and destroy threads frequently, and the task executes in a very short time, the overhead of creating and destroying threads is not negligible, and this is the opportunity for the thread pool to appear. If the thread creation and destruction times are negligible compared to the execution time of the task, there is no need to use the thread pool.
The following is a thread pool created under the Linux system in C language. The thread pool maintains a list of tasks (each cthread_worker structure is a task).
The Pool_init () function pre-creates max_thread_num threads, each with a thread_routine () function. In this function
- while (pool->cur_queue_size = = 0)
- {
- Pthread_cond_wait (& (Pool->queue_ready),& (Pool->queue_lock));
- }
Indicates that the thread is in a blocked wait state if there are no tasks in the task list. Otherwise, the task is removed from the queue and executed.
The Pool_add_worker () function adds a task to the task list of the thread pool and wakes up a blocked thread (if any) by calling Pthread_cond_signal (& (Pool->queue_ready)) after joining. )。
The Pool_destroy () function is used to destroy the thread pool, and the task in the thread pool task list will no longer be executed, but the running thread will keep the task running and then exit.
The complete code is posted below
- #include <stdio.h>
- #include <stdlib.h>
- #include <unistd.h>
- #include <sys/types.h>
- #include <pthread.h>
- #include <assert.h>
- /*
- * All running and waiting tasks in the thread pool are a cthread_worker
- * Since all tasks are in the list, it is a linked list structure
- */
- typedef struct Worker
- {
- / * callback function, which is called when the task is run, or it can be declared as a different form * /
- void * (*process) (void *arg);
- void *arg; / * Parameters for callback function * /
- struct worker *next;
- } Cthread_worker;
- /* Thread pool structure */
- typedef struct
- {
- pthread_mutex_t Queue_lock;
- pthread_cond_t Queue_ready;
- / * Linked list structure, all waiting tasks in the thread pool * /
- Cthread_worker *queue_head;
- / * Whether to destroy the thread pool * /
- int shutdown;
- pthread_t *threadid;
- / * Number of active threads allowed in the thread pool * /
- int max_thread_num;
- / * Number of tasks currently waiting for queue * /
- int cur_queue_size;
- } Cthread_pool;
- int Pool_add_worker (void * (*process) (void *arg), void *arg);
- void *thread_routine (void *arg);
- static Cthread_pool *pool = NULL;
- void
- Pool_init (int max_thread_num)
- {
- Pool = (Cthread_pool *) malloc (sizeof (Cthread_pool));
- Pthread_mutex_init (& (Pool->queue_lock), NULL);
- Pthread_cond_init (& (Pool->queue_ready), NULL);
- Pool->queue_head = NULL;
- Pool->max_thread_num = Max_thread_num;
- pool->cur_queue_size = 0;
- Pool->shutdown = 0;
- Pool->threadid =
- (pthread_t *) malloc (Max_thread_num * sizeof (pthread_t));
- int i = 0;
- For (i = 0; i < max_thread_num; i++)
- {
- Pthread_create (& (Pool->threadid[i]), NULL, Thread_routine,
- NULL);
- }
- }
- /* Join the task to the thread pool */
- Int
- Pool_add_worker (void* (*process) (void *arg), void *arg)
- {
- / * Construct a new task * /
- Cthread_worker *newworker =
- (Cthread_worker *) malloc (sizeof (Cthread_worker));
- newworker->process = process;
- Newworker->arg = arg;
- Newworker->next = NULL; / * Don't forget to empty * *
- Pthread_mutex_lock (& (Pool->queue_lock));
- / * Add tasks to the wait queue * /
- Cthread_worker *member = pool->queue_head;
- if (member! = NULL)
- {
- While (member->next! = NULL)
- member = member->next;
- Member->next = Newworker;
- }
- Else
- {
- Pool->queue_head = Newworker;
- }
- ASSERT (Pool->queue_head! = NULL);
- pool->cur_queue_size++;
- Pthread_mutex_unlock (& (Pool->queue_lock));
- / * OK, wait for the queue to have a task, wake up a waiting thread;
- Note that if all threads are busy, this sentence has no effect */
- Pthread_cond_signal (& (Pool->queue_ready));
- return 0;
- }
- /* Destroys the thread pool, waiting for tasks in the queue to no longer be executed, but the running thread will always
- Run the task and then exit */
- Int
- Pool_destroy ()
- {
- if (pool->shutdown)
- return-1; / * Prevent two calls * /
- Pool->shutdown = 1;
- / * Wake up all waiting threads and the thread pool will be destroyed * /
- Pthread_cond_broadcast (& (Pool->queue_ready));
- / * Block waiting thread to quit or become a zombie * *
- int i;
- For (i = 0; i < pool->max_thread_num; i++)
- Pthread_join (Pool->threadid[i], NULL);
- Free (pool->threadid);
- / * Destroy the wait queue * /
- Cthread_worker *head = NULL;
- While (pool->queue_head! = NULL)
- {
- Head = pool->queue_head;
- Pool->queue_head = pool->queue_head->next;
- Free (head);
- }
- /* Condition variable and mutex do not forget to destroy */
- Pthread_mutex_destroy (& (Pool->queue_lock));
- Pthread_cond_destroy (& (Pool->queue_ready));
- Free (pool);
- / * It's a good habit to empty the pointer after destroying it.
- Pool=null;
- return 0;
- }
- void *
- Thread_routine (void *arg)
- {
- printf ("Starting thread 0x%x\n", pthread_self ());
- While (1)
- {
- Pthread_mutex_lock (& (Pool->queue_lock));
- / * If the wait queue is 0 and the thread pool is not destroyed, be in a blocked state;
- Pthread_cond_wait is an atomic operation that will be unlocked before waiting, and will be locked when awakened.
- While (pool->cur_queue_size = = 0 &&!pool->shutdown)
- {
- printf ("Thread 0x%x is waiting\n", pthread_self ());
- Pthread_cond_wait (& (Pool->queue_ready), & (Pool->queue_lock));
- }
- / * thread pool to be destroyed * /
- if (pool->shutdown)
- {
- / * Encounter Break,continue,return and other jump statements, do not forget to unlock the first * /
- Pthread_mutex_unlock (& (Pool->queue_lock));
- printf ("thread 0x%x would exit\n", pthread_self ());
- Pthread_exit (NULL);
- }
- printf ("Thread 0x%x is starting to work\n", pthread_self ());
- /*assert is a good helper for commissioning * *
- ASSERT (Pool->cur_queue_size! = 0);
- ASSERT (Pool->queue_head! = NULL);
- / * Wait for the queue length minus 1 and remove the header element from the list * /
- pool->cur_queue_size--;
- Cthread_worker *worker = pool->queue_head;
- Pool->queue_head = worker->next;
- Pthread_mutex_unlock (& (Pool->queue_lock));
- / * Call the callback function to perform the task * /
- (* (worker->process)) (Worker->arg);
- Free (worker);
- worker = NULL;
- }
- / * This sentence should not be reached * /
- Pthread_exit (NULL);
- }
Here is the test code
- void *
- Myprocess (void *arg)
- {
- printf ("ThreadID is 0x%x, working on Task%d\n", Pthread_self (), * (int *) arg);
- Sleep (1); / * Take a second to extend the execution time of the task */
- return NULL;
- }
- Int
- Main (int argc, char **argv)
- {
- Pool_init (3); / * Up to three active threads in a thread pool * /
- / * Put 10 tasks into the pool continuously * /
- int *workingnum = (int *) malloc (sizeof (int) *);
- int i;
- For (i = 0; i <; i++)
- {
- Workingnum[i] = i;
- Pool_add_worker (Myprocess, &workingnum[i]);
- }
- / * Wait for all tasks to complete * /
- Sleep (5);
- / * Destroy thread pool * /
- Pool_destroy ();
- Free (workingnum);
- return 0;
- }
Put all of the above code into the threadpool.c file,
In the Linux input compilation command
$ gcc-o ThreadPool threadpool.c-lpthread
Here are the results of the operation
Starting thread 0xb7df6b90
Thread 0xb7df6b90 is waiting
Starting thread 0xb75f5b90
Thread 0xb75f5b90 is waiting
Starting thread 0xb6df4b90
Thread 0xb6df4b90 is waiting
Thread 0xb7df6b90 is starting to work
ThreadID is 0xb7df6b90, working on task 0
Thread 0xb75f5b90 is starting to work
ThreadID is 0xb75f5b90, working on Task 1
Thread 0xb6df4b90 is starting to work
ThreadID is 0xb6df4b90, working on Task 2
Thread 0xb7df6b90 is starting to work
ThreadID is 0xb7df6b90, working on task 3
Thread 0xb75f5b90 is starting to work
ThreadID is 0xb75f5b90, working on Task 4
Thread 0xb6df4b90 is starting to work
ThreadID is 0xb6df4b90, working on Task 5
Thread 0xb7df6b90 is starting to work
ThreadID is 0xb7df6b90, working on task 6
Thread 0xb75f5b90 is starting to work
ThreadID is 0xb75f5b90, working on task 7
Thread 0xb6df4b90 is starting to work
ThreadID is 0xb6df4b90, working on task 8
Thread 0xb7df6b90 is starting to work
ThreadID is 0xb7df6b90, working on task 9
Thread 0xb75f5b90 is waiting
Thread 0xb6df4b90 is waiting
Thread 0xb7df6b90 is waiting
Thread 0xb75f5b90 would exit
Thread 0xb6df4b90 would exit
Thread 0xb7df6b90 would exit
The principle and implementation of the thread pool of Linux platform
