线程池

源文件

#include "head.h"

void task_queue_init(struct task_queue *taskQueue, int size) {
    taskQueue->size = size;
    taskQueue->total = taskQueue->head = taskQueue->tail = 0;
    pthread_mutex_init(&taskQueue->mutex, NULL);
    pthread_cond_init(&taskQueue->cond, NULL);
    taskQueue->data = calloc(size, sizeof(void *));
    return ;
}

void task_queue_push(struct task_queue *taskQueue, char *str) {
    pthread_mutex_lock(&taskQueue->mutex);
    if (taskQueue->total == taskQueue->size) {
        printf("taskQueue is full!\n");
        pthread_mutex_unlock(&taskQueue->mutex);
        return ;
    }
    printf("<Push> : %s\n", str);
    taskQueue->data[taskQueue->tail++] = str;
    taskQueue->total++;
    taskQueue->tail %= taskQueue->size;
    pthread_cond_signal(&taskQueue->cond);
    pthread_mutex_unlock(&taskQueue->mutex);
}

char *task_queue_pop(struct task_queue *taskQueue) {
    pthread_mutex_lock(&taskQueue->mutex);
    if (taskQueue->total == 0) {
        printf("taskQueue is mpty!\n");
        pthread_cond_wait(&taskQueue->cond, &taskQueue->mutex);
    }
    char *str = taskQueue->data[taskQueue->head++];
    printf("<Pop> : %s\n", str);
    taskQueue->total--;
    taskQueue->head %= taskQueue->size;
    pthread_mutex_unlock(&taskQueue->mutex);
    return str;
}

测试文件

#include "head.h"
#define INS 5
#define QUEUE_SIZE 50

void *do_work(void *arg) {
    pthread_detach(pthread_self());
    struct task_queue *taskQueue = (struct task_queue *)arg;
    while (1) {
        char *str = task_queue_pop(taskQueue);
        printf("<%ld> : %s \n", pthread_self(), str);
    }
    return NULL;
}

int main() {
    pthread_t tid[INS + 1];
    struct task_queue taskQueue;
    task_queue_init(&taskQueue, QUEUE_SIZE);
    char buff[QUEUE_SIZE][1024] = {0};

    for (int i = 0; i < INS; i++) 
        pthread_create(&tid[i], NULL, do_work, (void *)&taskQueue);
    int sub = 0;
    while (1) {
        FILE *fp = fopen("./thread_pool_test.c", "r");
        if (!fp) {
            perror("fopen()");
            exit(1);
        }
        while (fgets(buff[sub], 1024, fp)) {
            task_queue_push(&taskQueue, buff[sub++]);
            sub %= QUEUE_SIZE;
            if (taskQueue.total == taskQueue.size) {
                while (1) {
                    if (taskQueue.total < taskQueue.size) break;
                    usleep(10000);
                }
            }
        }
        fclose(fp);
    }
    return 0;
}

头文件

#ifndef _HEAD_H
#define _HEAD_H
#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <dirent.h>
#include <string.h>
#include <errno.h>
#include <sys/time.h>
#include <time.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <pthread.h>
#include <sys/sem.h>
#include <sys/msg.h>

struct task_queue {
    int size;
    int total;
    int head;
    int tail;
    void **data;
    pthread_mutex_t mutex;
    pthread_cond_t cond;
};

void task_queue_init(struct task_queue *taskQueue, int size);
void task_queue_push(struct task_queue *taskQueue, char *str);
char *task_queue_pop(struct task_queue *taskQueue);
#endif