1 了解线程池

1-1线程池的概述

由一个任务队列和一组处理队列的线程组成。一旦工作进程需要处理某个可能“阻塞”的操作，不用自己操作，将其作为一个任务放到线程池的队列，接着会被某个空闲线程提取处理。

1-2线程池的组件

任务 		 待处理的工作，通常由标识、上下文和处理函数组成。
任务队列 	 按顺序保存待处理的任务序列，等待线程中的线程组处理。
线程池 		 由多个已启动的一组线程组成。
条件变量 	 一种同步机制，允许线程挂起，直到共享数据上的某些条件得到满足。
互斥锁 		 保证在任一时刻，只能有一个线程访问该对象。

2 互斥锁 与 条件变量 自定义封装 声明 与 定义

thread.h

#ifndef _DEMO_THREAD_H_INCLUDED_
#define _DEMO_THREAD_H_INCLUDED_

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <sys/types.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>

typedef intptr_t        int_t;
typedef uintptr_t       uint_t;

#define  OK          0
#define  ERROR      -1

//---------互斥量(互斥锁)接口的封装-----------定义:thread_mutex.c
int thread_mutex_create(pthread_mutex_t *mtx);				//线程 互斥锁的 创建
int thread_mutex_destroy(pthread_mutex_t *mtx);				//线程 互斥锁的 销毁
int thread_mutex_lock(pthread_mutex_t *mtx);				//线程 互斥锁的 加锁
int thread_mutex_unlock(pthread_mutex_t *mtx);				//线程 互斥锁的 解锁



//---------条件变量接口的封装-----------------定义:thread_cond.c
int thread_cond_create(pthread_cond_t *cond);				//线程 条件变量的 创建
int thread_cond_destroy(pthread_cond_t *cond);				//线程 条件变量的 销毁
int thread_cond_signal(pthread_cond_t *cond);				//线程 条件变量的 信号发送
int thread_cond_wait(pthread_cond_t *cond,					//线程 条件变量的 信号接受
					 pthread_mutex_t *mtx);	

#endif /* _DEMO_THREAD_H_INCLUDED_ */

thread_mutex.c

#include "thread.h"

//互斥锁的创建
int thread_mutex_create(pthread_mutex_t *mtx)
{
   
    int                   err;
    pthread_mutexattr_t  attr; 					 //互斥锁属性变量
   //1对互斥变量属性 pthread_mutexattr_t 初始化
    err = pthread_mutexattr_init(&attr);
    if (err != 0) {
   
        fprintf(stderr, "pthread_mutexattr_init() failed, reason: %s\n",strerror(errno));
        return ERROR;
    }

   //2设置互斥变量防 死锁检测 PTHREAD_MUTEX_ERRORCHECK 不允许同一个线程多次获取同一个锁导致的死锁
    err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
    if (err != 0) {
   
	fprintf(stderr, "pthread_mutexattr_settype(PTHREAD_MUTEX_ERRORCHECK) failed, reason: %s\n",strerror(errno));
        return ERROR;
    }

    //3对创建的互斥锁 mtx 设置 attr 属性
    err = pthread_mutex_init(mtx, &attr);
    if (err != 0) {
   
        fprintf(stderr,"pthread_mutex_init() failed, reason: %s\n",strerror(errno));
        return ERROR;
    }
    //3销毁互斥锁属性变量
    err = pthread_mutexattr_destroy(&attr);
    if (err != 0) {
   
	fprintf(stderr,"pthread_mutexattr_destroy() failed, reason: %s\n",strerror(errno));
    }

    return OK;
}

//互斥锁的销毁
int thread_mutex_destroy(pthread_mutex_t *mtx)
{
   
    int  err;

    err = pthread_mutex_destroy(mtx);
    if (err != 0) {
   
        fprintf(stderr,"pthread_mutex_destroy() failed, reason: %s\n",strerror(errno));
        return ERROR;
    }
    return OK;
}


//互斥锁上锁
int thread_mutex_lock(pthread_mutex_t *mtx)
{
   
    int  err;

    err = pthread_mutex_lock(mtx);
    if (err == 0) {
   
        return OK;
    }
	fprintf(stderr,"pthread_mutex_lock() failed, reason: %s\n",strerror(errno));

    return ERROR;
}

//互斥锁解锁
int thread_mutex_unlock(pthread_mutex_t *mtx)
{
   
    int  err;

    err = pthread_mutex_unlock(mtx);

#if 0
    ngx_time_update();
#endif

    if (err == 0) {
   
        return OK;
    }
	
	fprintf(stderr,"pthread_mutex_unlock() failed, reason: %s\n",strerror(errno));
    return ERROR;
}

thread_cond.c

#include "thread.h"

int thread_cond_create(pthread_cond_t *cond)
{
   
    int