linux 进程池实现,Linux C线程池简单实现实例

Linux C线程池

三个文件

1 tpool.h

typedef struct tpool_work {

void (*routine)(void *);

void *arg;

struct tpool_work *next;

} tpool_work_t;

typedef struct tpool {

/* pool characteristics */

int num_threads;

int max_queue_size;

/* pool state */

pthread_t *tpid;

tpool_work_t *queue;

int front, rear;

/* 剩下的任务可以做完, 但不能再加新的任务 */

int queue_closed;

/* 剩下的任务都不做了, 直接关闭 */

int shutdown;

/* pool synchronization */

pthread_mutex_t queue_lock;

pthread_cond_t queue_has_task;

pthread_cond_t queue_has_space;

pthread_cond_t queue_empty;

} *tpool_t;

void tpool_init(tpool_t *tpoolp,int num_threads, int max_queue_size);

int tpool_add_work(tpool_t tpool,void(*routine)(void *), void *arg);

int tpool_destroy(tpool_t tpool,int finish);

2 tpool.c

#include

#include

#include

#include

#include

#include

#include "tpool.h"

#define DEBUG

#if defined(DEBUG)

#define debug(...) do { \

flockfile(stdout); \

printf("###%p.%s: ", (void *)pthread_self(), __func__); \

printf(__VA_ARGS__); \

putchar('\n'); \

fflush(stdout); \

funlockfile(stdout); \

} while (0)

#else

#define debug(...)

#endif

void *tpool_thread(void *);

void tpool_init(tpool_t *tpoolp, int num_worker_threads, int max_queue_size)

{

int i;

tpool_t pool;

pool = (tpool_t)malloc(sizeof(struct tpool));

if (pool == NULL) {

perror("malloc");

exit(0);

}

pool->num_threads = 0;

pool->max_queue_size = max_queue_size + 1;

pool->num_threads = num_worker_threads;

pool->tpid = NULL;

pool->front = 0;

pool->rear = 0;

pool->queue_closed = 0;

pool->shutdown = 0;

if (pthread_mutex_init(&pool->queue_lock, NULL) == -1) {

perror("pthread_mutex_init");

free(pool);

exit(0);

}

if (pthread_cond_init(&pool->queue_has_space, NULL) == -1) {

perror("pthread_mutex_init");

free(pool);

exit(0);

}

if (pthread_cond_init(&pool->queue_has_task, NULL) == -1) {

perror("pthread_mutex_init");

free(pool);

exit(0);

}

if (pthread_cond_init(&pool->queue_empty, NULL) == -1) {

perror("pthread_mutex_init");

free(pool);

exit(0);

}

if ((pool->queue = malloc(sizeof(struct tpool_work) *

pool->max_queue_size)) == NULL) {

perror("malloc");

free(pool);

exit(0);

}

if ((pool->tpid = malloc(sizeof(pthread_t) * num_worker_threads)) == NULL) {

perror("malloc");

free(pool);

free(pool->queue);

exit(0);

}

for (i = 0; i < num_worker_threads; i++) {

if (pthread_create(&pool->tpid[i], NULL, tpool_thread,

(void *)pool) != 0) {

perror("pthread_create");

exit(0);

}

}

*tpoolp = pool;

}

int empty(tpool_t pool)

{

return pool->front == pool->rear;

}

int full(tpool_t pool)

{

return ((pool->rear + 1) % pool->max_queue_size == pool->front);

}

int size(tpool_t pool)

{

return (pool->rear + pool->max_queue_size -

pool->front) % pool->max_queue_size;

}

int tpool_add_work(tpool_t tpool, void(*routine)(void *), void *arg)

{

tpool_work_t *temp;

pthread_mutex_lock(&tpool->queue_lock);

while (full(tpool) && !tpool->shutdown && !tpool->queue_closed) {

pthread_cond_wait(&tpool->queue_has_space, &tpool->queue_lock);

}

if (tpool->shutdown || tpool->queue_closed) {

pthread_mutex_unlock(&tpool->queue_lock);

return -1;

}

int is_empty = empty(tpool);

temp = tpool->queue + tpool->rear;

temp->routine = routine;

temp->arg = arg;

tpool->rear = (tpool->rear + 1) % tpool->max_queue_size;

if (is_empty) {

debug("signal has task");

pthread_cond_broadcast(&tpool->queue_has_task);

}

pthread_mutex_unlock(&tpool->queue_lock);

return 0;

}

void *tpool_thread(void *arg)

{

tpool_t pool = (tpool_t)(arg);

tpool_work_t *work;

for (;;) {

pthread_mutex_lock(&pool->queue_lock);

while (empty(pool) && !pool->shutdown) {

debug("I'm sleep");

pthread_cond_wait(&pool->queue_has_task, &pool->queue_lock);

}

debug("I'm awake");

if (pool->shutdown == 1) {

debug("exit");

pthread_mutex_unlock(&pool->queue_lock);

pthread_exit(NULL);

}

int is_full = full(pool);

work = pool->queue + pool->front;

pool->front = (pool->front + 1) % pool->max_queue_size;

if (is_full) {

pthread_cond_broadcast(&pool->queue_has_space);

}

if (empty(pool)) {

pthread_cond_signal(&pool->queue_empty);

}

pthread_mutex_unlock(&pool->queue_lock);

(*(work->routine))(work->arg);

}

}

int tpool_destroy(tpool_t tpool, int finish)

{

int i;

pthread_mutex_lock(&tpool->queue_lock);

tpool->queue_closed = 1;

if (finish == 1) {

debug("wait all work done");

while (!empty(tpool)) {

pthread_cond_wait(&tpool->queue_empty, &tpool->queue_lock);

}

}

tpool->shutdown = 1;

pthread_mutex_unlock(&tpool->queue_lock);

pthread_cond_broadcast(&tpool->queue_has_task);

debug("wait worker thread exit");

for (i = 0; i < tpool->num_threads; i++) {

pthread_join(tpool->tpid[i], NULL);

}

debug("free thread pool");

free(tpool->tpid);

free(tpool->queue);

free(tpool);

}

3 tpooltest.c

#include

#include

#include "tpool.h"

char *str[]={"string 0", "string 1", "string 2",

"string 3", "string 4", "string 5"};

void job(void * jobstr)

{

long i, x;

for (i = 0; i < 100000000; i++) {

x = x +i;

}

printf("%s\n", (char *)jobstr);

}

int main(void)

{

int i;

tpool_t test_pool;

tpool_init(&test_pool, 8, 20);

for ( i = 0; i < 5; i++) {

tpool_add_work(test_pool, job, str[i]);

}

tpool_destroy(test_pool, 1);

return 0;

}

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！