线程池是一种常见的并发编程技术，它可以有效地管理线程，提高程序的并发性能。在 C 语言中，我们可以使用 POSIX 线程
库来实现
线程池。
以下是一个简单的 C 语言
线程池实现：
```c
#include <stdio.h>
#include <stdlib.h>
#include <p
thread.h>
#define MAX_
THREADS 10
#define MAX_QUEUE 1000
typedef struct {
void (*function)(void *);
void *argument;
} task_t;
static p
thread_mutex_t lock = P
THREAD_MUTEX_INITIALIZER;
static p
thread_cond_t notify = P
THREAD_COND_INITIALIZER;
static task_t task_queue[MAX_QUEUE];
static int queue_head = 0, queue_tail = 0, queue_size = 0;
static int shutdown = 0;
static p
thread_t
thread_
pool[MAX_
THREADS];
static int
thread_count = 0;
static void *
thread_function(void *arg) {
while (1) {
p
thread_mutex_lock(&lock);
while (queue_size == 0 && !shutdown) {
p
thread_cond_wait(¬ify, &lock);
}
if (shutdown) {
p
thread_mutex_unlock(&lock);
p
thread_exit(NULL);
}
void (*task_function)(void *);
void *task_argument;
task_function = task_queue[queue_head].function;
task_argument = task_queue[queue_head].argument;
queue_size--;
queue_head++;
if (queue_head == MAX_QUEUE) {
queue_head = 0;
}
p
thread_mutex_unlock(&lock);
(*task_function)(task_argument);
}
return NULL;
}
int
thread_
pool_init(int num_
threads) {
if (num_
threads <= 0 || num_
threads > MAX_
THREADS) {
num_
threads = MAX_
THREADS;
}
for (int i = 0; i < num_
threads; i++) {
if (p
thread_create(&
thread_
pool[i], NULL,
thread_function, NULL) != 0) {
return -1;
}
thread_count++;
}
return 0;
}
int
thread_
pool_add_task(void (*function)(void *), void *argument) {
p
thread_mutex_lock(&lock);
if (queue_size == MAX_QUEUE) {
p
thread_mutex_unlock(&lock);
return -1;
}
task_queue[queue_tail].function = function;
task_queue[queue_tail].argument = argument;
queue_size++;
queue_tail++;
if (queue_tail == MAX_QUEUE) {
queue_tail = 0;
}
p
thread_cond_signal(¬ify);
p
thread_mutex_unlock(&lock);
return 0;
}
int
thread_
pool_destroy() {
p
thread_mutex_lock(&lock);
shutdown = 1;
p
thread_cond_broadcast(¬ify);
p
thread_mutex_unlock(&lock);
for (int i = 0; i <
thread_count; i++) {
p
thread_join(
thread_
pool[i], NULL);
}
return 0;
}
```
使用方法如下：
```c
void print_message(void *arg) {
char *message = (char *) arg;
printf("%s\n", message);
free(message);
}
int main() {
thread_
pool_init(4);
for (int i = 0; i < 8; i++) {
char *message = malloc(sizeof(char) * 20);
sprintf(message, "Task %d", i);
thread_
pool_add_task(print_message, message);
}
thread_
pool_destroy();
return 0;
}
```
该示例代码中，我们定义了一个任务结构体 `task_t`，包含了任务函数指针和参数。
线程池中维护了一个任务队列，当有任务添加时，将任务加入队列，等待
线程池中的线程来执行。
线程池的每个线程都会从任务队列中取出一个任务并执行。
线程池的销毁通过发送停止信号来实现，即将 `shutdown` 标志设置为 1，并唤醒所有等待条件变量的线程。最后，等待所有线程执行结束，然后退出
线程池。
960
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
