实现简单的线程池

重点：多线程、锁
简单的线程池，并未使用I/O复用，有时间可以写一个epoll的

如有错误，欢迎指正

主要的函数如下

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<assert.h>

#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>

#include<pthread.h>
#include<semaphore.h>

#define THREAD_MAX 5
#define BUFFSIZE 10
sem_t sem; 
pthread_mutex_t mutex;//互斥锁
int Buff_Fd[BUFFSIZE];

//初始化全局数组，存储已连接的文件描述符
void InitBuffFd(){}
//将已连接的文件描述符插入到全局数组中//要实现互斥
void InsertBuffFd(int fd){}
//从全局数组中获取一个已连接的文件描述符,并且将它初始化为-1
int GetBuffFd(){}
//初始化监听文件描述符
int InitSocket(){}
//工作线程函数
void *work_thread(void *arg){}

int main(){}

**主函数：

int main(){

    sem_init(&sem,0,0);//初始化信号
    pthread_mutex_init(&mutex,NULL);//初始化锁
    InitBuffFd();//初始化数组
    int sockfd = InitSocket();
    assert(sockfd != -1);

    pthread_t id[BUFFSIZE];
    for(int i = 0;i<THREAD_MAX;++i){
        int res = pthread_create(&id[i],NULL,work_thread,NULL);
        assert(res == 0);
    }

    while(1){
        struct sockaddr_in cli_addr;
        memset(&cli_addr,0,sizeof(cli_addr));
        socklen_t addrlen = sizeof(cli_addr);
        int c =accept(sockfd,(struct sockaddr*)&cli_addr,&addrlen);
        if(c <= 0){
            continue;
        }
        //将c传给工作线程   --  》  添加到数组中
        InsertBuffFd(c);
        //唤醒一个工作线程  --  》  执行v操作
        sem_post(&sem);
        
    }   
    close(sockfd);
    //销毁线程
    /*for(int i = 0;i<THREAD_MAX;++i){
    }*/
    exit(0);//暴力结束主线程，也把子线程也结束
}

1.代码是死的

//初始化监听文件描述符
int InitSocket(){
    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    assert(sockfd != -1);

    struct sockaddr_in ser_addr;
    memset(&ser_addr,0,sizeof(ser_addr));
    ser_addr.sin_family = AF_INET;
    ser_addr.sin_port = htons(6000);
    ser_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    int res = bind(sockfd,(struct sockaddr*)&ser_addr,sizeof(ser_addr));
    assert(res != -1);

    res = listen(sockfd,5);
    assert(res != -1);

    return sockfd;
}

2.初始化全局数组

//初始化全局数组，存储已连接的文件描述符
void InitBuffFd(){
    for(int i = 0;i<BUFFSIZE;++i){
        Buff_Fd[i] = -1;
    }
}

3.插入文件描述符，因为和获取函数操作同一块资源（全局数组），所以要加锁

//将已连接的文件描述符插入到全局数组中//要实现互斥
void InsertBuffFd(int fd){
    pthread_mutex_lock(&mutex);//加锁
    for(int i = 0;i<BUFFSIZE;++i){
        if(Buff_Fd[i] == -1){
            Buff_Fd[i] = fd;
            break;
        }
    }
    pthread_mutex_unlock(&mutex);//解锁
}

4.获取一个连接

//从全局数组中获取一个已连接的文件描述符,并且将它初始化为-1
int GetBuffFd(){
    pthread_mutex_lock(&mutex);
    int fd = -1;
    for(int i = 0;i<BUFFSIZE;++i){
        if(Buff_Fd[i] != -1){
            fd =  Buff_Fd[i];
            Buff_Fd[i] = -1;
            break;
        }
    }
    pthread_mutex_unlock(&mutex);
    return fd;
}

5.工作函数

void *work_thread(void *arg){
    while(1){
        sem_wait(&sem);
        //1全局数组，获取一个文件描述符
        int fd = GetBuffFd();
        if( fd == -1) continue;
        //2拿到文件描述符，完成交互
        while(1){
            char buff[128] = {0};
            int n = recv(fd,buff,127,0);
            if(n <= 0){
                printf("one client unlink\n");
                close(fd);
                break;
            }
            printf(" n = %d buff = %s\n",n,buff);
            int res = send(fd,"ok",2,0);
            if(res <= 0){
                printf("send error\n");
                close(fd);
                break;
            }
        }

    }
}