2021.4.14学习笔记

链表（线程池）

多线程存在的问题：

进程所支持的线程数量问题（受限）
线程的创建和销毁的开销问题

为什么需要线程池

大多数的网络服务器，包括Web服务器都具有一个特点，就是单位时间内必须处理数目巨大的连接请求，但是处理时间却是比较短的。在传统的多线程服务器模型中是这样实现的：一旦有个请求到达，就创建一个新的线程，由该线程执行任务，任务执行完毕之后，线程就退出。这就是”即时创建，即时销毁”的策略。尽管与创建进程相比，创建线程的时间已经大大的缩短，但是如果提交给线程的任务是执行时间较短，而且执行次数非常频繁，那么服务器就将处于一个不停的创建线程和销毁线程的状态。这笔开销是不可忽略的，尤其是线程执行的时间非常非常短的情况。

原理

线程池就是为了解决上述问题的，它的实现原理是这样的：在应用程序启动之后，就马上创建一定数量的线程，放入空闲的队列中。这些线程都是处于阻塞状态，这些线程只占一点内存，不占用CPU。当任务到来后，线程池将选择一个空闲的线程，将任务传入此线程中运行。当所有的线程都处在处理任务的时候，线程池将自动创建一定的数量的新线程，用于处理更多的任务。执行任务完成之后线程并不退出，而是继续在线程池中等待下一次任务。当大部分线程处于阻塞状态时，线程池将自动销毁一部分的线程，回收系统资源。
下面是一个简单线程池的实现，它的方案是这样的：程序启动之前，初始化线程池，启动线程池中的线程，由于还没有任务到来，线程池中的所有线程都处在阻塞状态，当一有任务到达就从线程池中取出一个空闲线程处理，如果所有的线程都处于工作状态，就添加到队列，进行排队。如果队列中的任务个数大于队列的所能容纳的最大数量，那就不能添加任务到队列中，只能等待队列不满才能添加任务到队列中。

条件：
1、任务队列是不是空
2、任务队列为满
3、任务队列不为空

任务队列为空时，线程池里的线程阻塞等待
任务队列为满时，不能添加新的任务
任务队列不为空时，线程池里的线程处理任务

int thread_num; //已开启的线程数量
struct job *head; //任务队列的头指针
struct job *tail; //任务队列的尾指针
int queue_max_num; //任务队列的最大数
int queue_cui_num; //任务队列已有多少个任务
pthread_t *pthread_ids; //保存线程池中线程的id
pthread_cond_t queue_empty;//任务队列为空的条件
pthread_cond_t queue_not_empty;//任务队列不为空的条件
pthread_cond_t queue_not_full;//任务队列不为满的条件
每个线程都输出helloworld和welcome to china

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

struct job
{
    void *(*func)(void *arg);
    void *arg;
    struct job *next;
};

struct threadpool
{
    int thread_num;//已开启的线程数量
    pthread_t *pthread_ids;//保存线程池中线程的id

    struct job *head; //任务队列的头指针
    struct job *tail;//任务队列的尾指针
    int queue_max_num; //任务队列的最大数
    int queue_cur_num; //任务队列已有多少个任务

    pthread_mutex_t mutex;
    pthread_cond_t queue_empty;//任务队列为空的条件
    pthread_cond_t queue_not_empty;//任务队列不为空的条件
    pthread_cond_t queue_not_full;//任务队列不为满的条件

};

void *threadpool_function(void *arg)
{
    struct threadpool *pool = (struct threadpool *)arg;
    struct job *pjob = NULL;

    while(1)
    {
        pthread_mutex_lock(&(pool->mutex));
        while (pool->queue_cur_num == 0)
        {
            pthread_cond_wait(&(pool->queue_not_empty),&(pool->mutex));
        }
        
        pjob = pool->head;
        pool->queue_cur_num--;
        if(pool->queue_cur_num != pool->queue_max_num)
        {
            pthread_cond_broadcast(&(pool->queue_not_empty));
        }
        if (pool->queue_cur_num ==0)
        {
            pool->head = pool->tail = NULL;
        }
        else
        {
            pool->head = pool->head->next;
        }
        pthread_mutex_unlock(&(pool->mutex));
        
        (*(pjob->func))(pjob->arg);
        
        free(pjob);
        pjob = NULL;
        

    }
}


struct threadpool *threadpool_init(int thread_num, int queue_max_num)
{
    struct threadpool *pool = (struct threadpool *)malloc(sizeof(struct threadpool));
    //malloc


    pool->queue_max_num = queue_max_num;
    pool->queue_cur_num = 0;
    pool->head = NULL;
    pool->tail = NULL;

    pthread_mutex_init(&(pool->mutex),NULL);
    pthread_cond_init(&(pool->queue_empty),NULL);
    pthread_cond_init(&(pool->queue_not_empty),NULL);
    pthread_cond_init(&(pool->queue_not_full),NULL);

    pool->thread_num = thread_num;
    pool->pthread_ids = (pthread_t *)malloc(sizeof(pthread_t) *thread_num);
    //malloc
    for (int i = 0; i < pool->thread_num; i++)
    {
        pthread_create(&(pool->pthread_ids[i]),NULL, threadpool_function, (void *)pool);
    }

    return pool;
}

void threadpool_add_job(struct threadpool *pool, void *(func)(void *),void *arg)
{
    pthread_mutex_lock(&(pool->mutex));
    while(pool->queue_cur_num == pool->queue_max_num)
    {
        pthread_cond_wait((&pool->queue_not_full),&(pool->mutex));
    }



    struct job *pjob = (struct job*)malloc(sizeof(struct job));
    //malloc
    
    pjob->func = func;
    pjob->arg = arg;
    pjob->next = NULL;

    //pjob->func(pjob->arg);
    if(NULL == pool->head)
    {
        pool->head = pool->tail = pjob;
        pthread_cond_broadcast(&(pool->queue_not_empty));
    }
    else
    {
        pool->tail->next = pjob;
        pool->tail = pjob;
    }
    
    pool->tail->next = pjob;
    pool->tail = pjob;

    pool->queue_cur_num++;
    //printf("%d\n",pool->queue_cur_num);

    pthread_mutex_unlock(&(pool->mutex));
}

void thread_destroy(struct threadpool *pool)
{
    pthread_mutex_lock(&(pool->mutex));
    while(pool->queue_cur_num != 0)
    {
        pthread_cond_wait(&(pool->queue_empty),&(pool->mutex));
    }
    pthread_mutex_unlock(&(pool->mutex));
    pthread_cond_broadcast(&(pool->queue_empty));
    pthread_cond_broadcast(&(pool->queue_not_empty));
    pthread_cond_broadcast(&(pool->queue_not_full));
    free(pool->pthread_ids);

    for (int i = 0;i<pool->thread_num;i++)
    {
        pthread_cancel(pool->pthread_ids[i]);
        pthread_join(pool->pthread_ids[i],NULL);
    }

    struct job *temp;
    while(pool->head != NULL)
    {
        temp = pool->head;
        pool->head = temp->next;
        free(temp);
    }
    free(pool);

}


void *work(void *arg)
{
    char *p = (char *)arg;
    printf("hello world!  %s\n",p);
    printf("welcome to china!  %s\n",p);
    sleep(1);
}

int main()
{
    struct threadpool *pool = threadpool_init(10, 100);
    threadpool_add_job(pool,work,"1");
    threadpool_add_job(pool,work,"2");
    threadpool_add_job(pool,work,"3");
    threadpool_add_job(pool,work,"4");
    threadpool_add_job(pool,work,"5");
    threadpool_add_job(pool,work,"6");
    threadpool_add_job(pool,work,"7");
    threadpool_add_job(pool,work,"8");
    threadpool_add_job(pool,work,"9");
    threadpool_add_job(pool,work,"10");

    threadpool_add_job(pool,work,"11");
    threadpool_add_job(pool,work,"22");
    threadpool_add_job(pool,work,"33");
    threadpool_add_job(pool,work,"44");
    threadpool_add_job(pool,work,"55");
    threadpool_add_job(pool,work,"66");
    threadpool_add_job(pool,work,"77");
    threadpool_add_job(pool,work,"88");
    threadpool_add_job(pool,work,"99");
    threadpool_add_job(pool,work,"100");
    
    sleep(20);
    thread_destroy(pool);
    return 0;
}