嵌入式系統開發

鏈表

1、任務佇列

（1）任務佇列為空
（2）任務佇列為滿
（3）任務佇列為不為空

任務佇列為空時，執行緒池里的執行緒阻塞等待
任務佇列不為空時，執行緒池里的執行緒處理任務
任務佇列為滿，不能再添加新的任務

2、執行緒池

（1）執行緒池里的執行緒數量
（2）執行緒池里的作業執行緒數量
（3）任務佇列的大小
（4）任務佇列鎖

example：

#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 ;
            pthread_cond_broadcast(&(pool->queue_not_empty));
        }
        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
    //int thread_num = 20;
    //int queue_max_num = 100;

    pool->thread_num = thread_num ;
    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->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->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->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_not_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);
    
    
    return 0;
}

注釋：
int thread_num； //已開啟的執行緒
struct job *head；//任務佇列的頭
struct job *tail； //任務佇列的尾
int queue_max_num；//任務佇列的最大數
int queue_cur_num；//任務佇列已有多少個任在這里插入代碼片務
pthread_t *pthread_ids；//保存執行緒池中執行緒的id
pthread_mutex_t mutex；//定義任務鎖
pthread_cond_t queue_empty;//任務佇列為空
pthread_cond_t queue_not_empty;//任務佇列不為空
pthread_cond_t queue_not_full;//任務佇列不為滿