以下是一个简单的C语言
线程池的代码实现：
```c
#include <p
thread.h>
#include <stdlib.h>
#include <stdio.h>
#define DEFAULT_
THREADS 4
typedef struct {
void (*function)(void *);
void *argument;
}
thread_task;
typedef struct {
thread_task *task_queue;
int queue_size;
int front;
int rear;
int count;
p
thread_mutex_t lock;
p
thread_cond_t not_empty;
p
thread_cond_t not_full;
int
threads_count;
p
thread_t *
threads;
int shutdown;
}
thread_pool;
void *
thread_pool_function(void *
thread_pool_ptr) {
thread_pool *pool = (
thread_pool *)
thread_pool_ptr;
thread_task task;
while (1) {
p
thread_mutex_lock(&(pool->lock));
while (pool->count == 0 && !pool->shutdown) {
p
thread_cond_wait(&(pool->not_empty), &(pool->lock));
}
if (pool->shutdown) {
p
thread_mutex_unlock(&(pool->lock));
p
thread_exit(NULL);
}
task = pool->task_queue[pool->front];
pool->front = (pool->front + 1) % pool->queue_size;
pool->count--;
if (pool->count == pool->queue_size - 1) {
p
thread_cond_broadcast(&(pool->not_full));
}
p
thread_mutex_unlock(&(pool->lock));
(*(task.function))(task.argument);
}
p
thread_exit(NULL);
}
int
thread_pool_create(
thread_pool *pool, int
threads_count) {
int i;
pool->
threads_count = 0;
pool->shutdown = 0;
if (
threads_count <= 0) {
threads_count = DEFAULT_
THREADS;
}
pool->queue_size =
threads_count * 2;
pool->front = 0;
pool->rear = 0;
pool->count = 0;
pool->task_queue = (
thread_task *) malloc(sizeof(
thread_task) * pool->queue_size);
pool->
threads = (p
thread_t *) malloc(sizeof(p
thread_t) *
threads_count);
p
thread_mutex_init(&(pool->lock), NULL);
p
thread_cond_init(&(pool->not_empty), NULL);
p
thread_cond_init(&(pool->not_full), NULL);
for (i = 0; i <
threads_count; i++) {
p
thread_create(&(pool->
threads[i]), NULL,
thread_pool_function, (void *) pool);
pool->
threads_count++;
}
return 0;
}
int
thread_pool_add_task(
thread_pool *pool, void (*function)(void *), void *argument) {
thread_task task;
p
thread_mutex_lock(&(pool->lock));
while (pool->count == pool->queue_size && !pool->shutdown) {
p
thread_cond_wait(&(pool->not_full), &(pool->lock));
}
if (pool->shutdown) {
p
thread_mutex_unlock(&(pool->lock));
return -1;
}
task.function = function;
task.argument = argument;
pool->task_queue[pool->rear] = task;
pool->rear = (pool->rear + 1) % pool->queue_size;
pool->count++;
if (pool->count == 1) {
p
thread_cond_broadcast(&(pool->not_empty));
}
p
thread_mutex_unlock(&(pool->lock));
return 0;
}
int
thread_pool_destroy(
thread_pool *pool) {
int i;
if (pool->shutdown) {
return -1;
}
pool->shutdown = 1;
p
thread_cond_broadcast(&(pool->not_empty));
p
thread_cond_broadcast(&(pool->not_full));
for (i = 0; i < pool->
threads_count; i++) {
p
thread_
join(pool->
threads[i], NULL);
}
free(pool->task_queue);
free(pool->
threads);
p
thread_mutex_destroy(&(pool->lock));
p
thread_cond_destroy(&(pool->not_empty));
p
thread_cond_destroy(&(pool->not_full));
return 0;
}
void task_function(void *argument) {
int *value = (int *) argument;
printf("Task %d\n", *value);
}
int main() {
int i;
int values[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
thread_pool pool;
thread_pool_create(&pool, 4);
for (i = 0; i < 10; i++) {
thread_pool_add_task(&pool, task_function, &values[i]);
}
thread_pool_destroy(&pool);
return 0;
}
```
该实现使用一个循环队列来存储
线程任务，
线程池的每个
线程都会不断地从队列中取出任务并执行。
线程池的创建、添加任务和销毁都是
线程安全的，确保了多
线程环境下
线程池的正确性。在本例中，我们创建了一个包含10个任务的
线程池，每个任务打印一个数字。
276
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
