13.1 多线程操作共享内存、生产者消费者模型、多线程服务器框架

　　生产者消费者模型如下：

程序如下：

#include <unistd.h>
#include <sys/types.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#include <pthread.h>

int g_Count = 0;

int     nNum, nLoop;

//定义锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

//定义条件并初始化
pthread_cond_t my_condition=PTHREAD_COND_INITIALIZER;

#define CUSTOM_COUNT 2
#define PRODUCT_COUNT 4


  // int pthread_mutex_lock(pthread_mutex_t *mutex);
  //     int pthread_mutex_trylock(pthread_mutex_t *mutex);
   //    int pthread_mutex_unlock(pthread_mutex_t *mutex);

/*
       int pthread_cond_timedwait(pthread_cond_t *restrict cond,
              pthread_mutex_t *restrict mutex,
              const struct timespec *restrict abstime);
       int pthread_cond_wait(pthread_cond_t *restrict cond,
              pthread_mutex_t *restrict mutex);
              */

//posix 线程库的函数 线程库
void *consume(void* arg)
{
    
    int inum = 0;
    inum = (int)arg;
    while(1)
    {
        pthread_mutex_lock(&mutex);
        printf("consum:%d
", inum);
        while (g_Count == 0)  //while 醒来以后需要重新判断 条件g_Count是否满足，如果不满足，再次wait
        {
            printf("consum:%d 开始等待
", inum);
            pthread_cond_wait(&my_condition, &mutex); //api做了三件事情 //pthread_cond_wait假醒
            printf("consum:%d 醒来
", inum);
        }
    
        printf("consum:%d 消费产品begin
", inum);
        g_Count--; //消费产品
        printf("consum:%d 消费产品end
", inum);
        
        pthread_mutex_unlock(&mutex);
    
        sleep(1);
    }

    pthread_exit(0);

} 

//生产者线程
//
void *produce(void* arg)
{
    int inum = 0;
    inum = (int)arg;
    
    while(1)
    {
    
    /*
        //因为是很多生产者调用produce，要保护全局变量g_Count，所以加锁 
        pthread_mutex_lock(&mutex);
        if (g_Count > 20)
        {
            printf("produce:%d 产品太多，需要控制，休眠
", inum);
            pthread_mutex_unlock(&mutex);
            sleep(1);
            continue;
        }
        else
        {
            pthread_mutex_unlock(&mutex);
        }
        */
    
        pthread_mutex_lock(&mutex);
        printf("产品数量:%d
", g_Count);
        printf("produce:%d 生产产品begin
", inum);
        g_Count++;
        //只要我生产出一个产品，就告诉消费者去消费
        printf("produce:%d 生产产品end
", inum);
        
        printf("produce:%d 发条件signal begin
", inum);
        pthread_cond_signal(&my_condition); //通知，在条件上等待的线程 
        printf("produce:%d 发条件signal end
", inum);
        
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
    
    pthread_exit(0);

} 

//结论：return arg 和 pthread_exit（）的结果都可以让pthread_join 接过来
int main()
{
    int        i =0;
    pthread_t    tidArray[CUSTOM_COUNT+PRODUCT_COUNT+10];
    
    //创建消费者线程
    for (i=0; i<CUSTOM_COUNT; i++)
    {
        pthread_create(&tidArray[i], NULL, consume, (void *)i);
    }
    
    sleep(1);
    //创建生产线程
    for (i=0; i<PRODUCT_COUNT; i++)
    {
        pthread_create(&tidArray[i+CUSTOM_COUNT], NULL, produce, (void*)i);
    }
    
    
    
    for (i=0; i<CUSTOM_COUNT+PRODUCT_COUNT; i++)
    {
        pthread_join(tidArray[i], NULL); //等待线程结束。。。
    }
    
    
    printf("进程也要结束1233
");
    
    return 0;
}

执行结果如下：

 条件等待模型如下：

多线程访问共享内存，通过信号量同步：不同进程中的线程无法进行同步与互斥

#include <sys/types.h>
#include <unistd.h>

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

#include <signal.h>
#include <errno.h>
#include <signal.h>
#include <sys/wait.h>

#include "myipc_sem.h"
#include "myipc_shm.h"

#include <pthread.h>

int g_key = 0x3333;

void TestFunc(int loopnum)
{
    printf("loopnum:%d
", loopnum);
    
    int ncount = 0;
    int ret = 0;
    int shmhdl = 0;
    int *addr = NULL;
    
    int semid = 0;
    sem_open(g_key, &semid);


     sem_p(semid); //临界区开始
    //
        ret = IPC_CreatShm(".", 0, &shmhdl);
        
        ret =IPC_MapShm(shmhdl, (void **)&addr);
        *((int *)addr) =  *((int *)addr)  + 1;
        ncount = *((int *)addr);
        printf("ncount:%d
", ncount);
        //addr[0] = addr[0] +1;
        ret =IPC_UnMapShm(addr);
        //sleep(2);
        
    sem_v(semid);  //临界区开始
    //
    printf("进程正常退出:%d
", getpid());
}    



//posix 线程库的函数 线程库
void *thread_routine(void* arg)
{
    printf("thread_routine start
");
    TestFunc(1);
    pthread_exit(0);

} 

int main(void )
{
    int res;
    int procnum=10;
    int loopnum = 100;
    
    pthread_t tidArray[200];


    int  i=0,j = 0;

    printf("请输入要创建子进程的个数 : 
");
    scanf("%d", &procnum);

    printf("请输入让每个子进程测试多少次 :
");
    scanf("%d", &loopnum);
    
    //共享内存创建
    int        ret = 0;
    int     shmhdl = 0;
    ret = IPC_CreatShm(".", sizeof(int), &shmhdl);
    if (ret != 0)
    {
        printf("func IPC_CreatShm() err:%d 
", ret);
        return ret;
    }
    
    
    //信号量的创建
     int      semid = 0;
    ret = sem_creat(g_key, &semid);
    if (ret != 0)
    {
        printf("func sem_creat() err:%d,重新按照open打开信号量 
", ret);
        if (ret == SEMERR_EEXIST)
        {
            ret = sem_open(g_key, &semid);
            if (ret != 0)
            {
                printf("按照打开的方式，重新获取sem失败:%d 
", ret);
                return ret;
            }
        }
        else
        {
            return ret;
        }
        
    }
    
    int  val = 0;
    ret = sem_getval(semid, &val);
    if (ret != 0 )
    {
        printf("func sem_getval() err:%d 
", ret);
        return ret;
    }
    printf("sem val:%d
", val);
    getchar();
    
    for (i=0; i<procnum; i++)
    {
    
        //tmp.numId = i; //这说明 线程函数在使用了一个不断变化的内存空间。。。。
        pthread_create(&tidArray[i], NULL, thread_routine, NULL);
    }
    
    for (i=0; i<procnum; i++)
    {
        pthread_join(tidArray[i], NULL); //等待线程结束。。。
    }


    printf("父进程退出 hello...
");
    return 0;
}

多线程访问共享内存，通过线程锁实现：

#include <sys/types.h>
#include <unistd.h>

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

#include <signal.h>
#include <errno.h>
#include <signal.h>
#include <sys/wait.h>

#include "myipc_sem.h"
#include "myipc_shm.h"

#include <pthread.h>

pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;

int g_key = 0x3333;

void TestFunc(int loopnum)
{
    printf("loopnum:%d
", loopnum);
    
    int ncount = 0;
    int ret = 0;
    int shmhdl = 0;
    int *addr = NULL;
    
    int semid = 0;
    sem_open(g_key, &semid);


     sem_p(semid); //临界区开始
    //
        ret = IPC_CreatShm(".", 0, &shmhdl);
        
        ret =IPC_MapShm(shmhdl, (void **)&addr);
        *((int *)addr) =  *((int *)addr)  + 1;
        ncount = *((int *)addr);
        printf("ncount:%d
", ncount);
        //addr[0] = addr[0] +1;
        ret =IPC_UnMapShm(addr);
        //sleep(2);
        
    sem_v(semid);  //临界区开始
    //
    printf("进程正常退出:%d
", getpid());
}    

void TestFunc_threadMutex(int loopnum)
{
    printf("loopnum:%d
", loopnum);
    
    int ncount = 0;
    int ret = 0;
    int shmhdl = 0;
    int *addr = NULL;
    
    int semid = 0;
    sem_open(g_key, &semid);


     //sem_p(semid); //临界区开始
     pthread_mutex_lock(&mymutex);
    //
        ret = IPC_CreatShm(".", 0, &shmhdl);
        
        ret =IPC_MapShm(shmhdl, (void **)&addr);
        *((int *)addr) =  *((int *)addr)  + 1;
        ncount = *((int *)addr);
        printf("ncount:%d
", ncount);
        //addr[0] = addr[0] +1;
        ret =IPC_UnMapShm(addr);
        //sleep(2);
        
    //sem_v(semid);  //临界区开始
    pthread_mutex_unlock(&mymutex);
    //
    printf("进程正常退出:%d
", getpid());
}    




//posix 线程库的函数 线程库
void *thread_routine(void* arg)
{
    printf("thread_routine start
");
    //TestFunc(1);
    TestFunc_threadMutex(1);
    pthread_exit(0);

} 

int main(void )
{
    int res;
    int procnum=10;
    int loopnum = 100;
    
    pthread_t tidArray[1024*10];


    int  i=0,j = 0;

    printf("请输入要创建子进程的个数 : 
");
    scanf("%d", &procnum);

    printf("请输入让每个子进程测试多少次 :
");
    scanf("%d", &loopnum);
    
    //共享内存创建
    int        ret = 0;
    int     shmhdl = 0;
    ret = IPC_CreatShm(".", sizeof(int), &shmhdl);
    if (ret != 0)
    {
        printf("func IPC_CreatShm() err:%d 
", ret);
        return ret;
    }
    
    
    //信号量的创建
     int      semid = 0;
    ret = sem_creat(g_key, &semid);
    if (ret != 0)
    {
        printf("func sem_creat() err:%d,重新按照open打开信号量 
", ret);
        if (ret == SEMERR_EEXIST)
        {
            ret = sem_open(g_key, &semid);
            if (ret != 0)
            {
                printf("按照打开的方式，重新获取sem失败:%d 
", ret);
                return ret;
            }
        }
        else
        {
            return ret;
        }
        
    }
    
    int  val = 0;
    ret = sem_getval(semid, &val);
    if (ret != 0 )
    {
        printf("func sem_getval() err:%d 
", ret);
        return ret;
    }
    printf("sem val:%d
", val);
    getchar();
    
    for (i=0; i<procnum; i++)
    {
    
        //tmp.numId = i; //这说明 线程函数在使用了一个不断变化的内存空间。。。。
        pthread_create(&tidArray[i], NULL, thread_routine, NULL);
    }
    
    for (i=0; i<procnum; i++)
    {
        pthread_join(tidArray[i], NULL); //等待线程结束。。。
    }


    printf("父进程退出 hello...
");
    return 0;
}

服务器多进程模型、共享内存、信号量：

信号量封装：

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#include <sys/ipc.h>
#include <sys/sem.h>
#include "myipc_sem.h"


union semun {
int              val;    /* Value for SETVAL */
struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
unsigned short  *array;  /* Array for GETALL, SETALL */
struct seminfo  *__buf;  /* Buffer for IPC_INFO
                           (Linux specific) */
};

//@返回值 0 正确 其他错误
int sem_creat(int key, int *semid)
{
    int     ret = 0;
    //int     tmpsemid = 0;
    
    if (semid == NULL)
    {
        ret = SEMERR_PARAM;
        printf("func sem_creat() err:%d
", ret);
        return ret;
    }
    ret = semget(key, 1, 0666| IPC_CREAT | IPC_EXCL); 
    if (ret == -1)
    {
            ret = errno;
            //perror("semget");
            if (errno == EEXIST) 
            {
                ret = SEMERR_EEXIST;
                printf("func sem_creat() 检测到信号量集已经存在:%d
", ret);
                return ret;
            }
    }
    *semid = ret;
    
    ret = sem_setval(*semid, 1);
    if (ret != 0)
    {
        printf("func sem_setval() err:%d
", ret);
        return ret;
    }
    ret = 0;
    return ret;
}   

int sem_open(int key, int *semid)
{
    int ret = 0;
    
    if (semid == NULL)
    {
        ret = SEMERR_PARAM;
        printf("func sem_open() err:%d
", ret);
        return ret;
    }
    
    ret = semget(key, 0, 0); 
    if (ret == -1)
    {
            ret = errno;
            printf("func sem_open() 失败:%d
", ret);
            return ret;    
    }
    *semid = ret;
    ret = 0;
    return ret;
}  

int sem_setval(int semid, int val)
{
    int ret = 0;
    union semun su;
    su.val = val;
    ret = semctl(semid, 0,  SETVAL, su);
    return ret;
}

/*
int sem_getval(int semid, int *val)
{
    int ret = 0;
    int tmpval;
    if (val == NULL)
    {
        ret = SEMERR_PARAM;
        printf("func sem_getval() err:%d
", ret);
        return ret;
    }
    union semun su;
    tmpval = su.val ;
    ret = semctl(semid, 0, GETVAL, su);
    *val = tmpval  ;
    printf("val:%d
", tmpval);
    return ret;
}
*/
int sem_getval(int semid, int *myval)
{
    int ret = 0;
    int val;
    union semun su;
    val = su.val ;
    //信号量 计数值
    ret = semctl(semid, 0, GETVAL, su);
    //printf("val:%d
", val);
    
    *myval = ret;
    ret = 0;
    return ret;
}

//信号量p操作时候，需要传递好几个信息给linux内核
//所以linux内核定义了一个结构
//我要操作信号量集的下标 0
//我要执行什么操作 -1 +1
//我按照什么策略执行操作 0  UNDO NOWAITing
int sem_p(int semid)
{
    struct sembuf buf = {0, -1, 0};
    int ret = 0;
    ret = semop(semid, &buf, 1);
    return ret;
}

int sem_v(int semid)
{
    struct sembuf buf = {0, 1, 0};
    int ret = 0;
    ret = semop(semid, &buf, 1);
    return ret;
}


/*
int main()
{
    
    //IPC_CREAT and IPC_EXCL a
    int semid;
    semid  = sem_creat(0x1111);
    //sem_setval(semid, 1);
    //sem_getval(semid);
    
    
    int pid = 0;
    pid = fork();
    

    //sem_p(semid);
        int i=0;
    //    printf("i:%d pid:%d 
", i++, getpid());
    //    sleep(3);
    //    printf("i:%d pid:%d 
", i++, getpid());
        
    //sem_v(semid);
    
    
    
    return 0;
}
*/

共享内存封装：

#define    _OS_LINUX_

#if defined _OS_LINUX_
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <memory.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/msg.h>
#include "myipc_shm.h" 

#endif

int shmflag = 0;
int shmkey;

/***********************************************************************
  功能描述：    创建共享内存
  参数说明：    shmname  [in]  是共享内存名,系统中唯一标志
                shmsize  [in]  是要创建的共享内存的大小；
                shmhdl   [out] 共享内存的句柄.
  返回值：      返回0函数执行成功；非0返回错误码
************************************************************************/
int IPC_CreatShm(char *shmseedfile, int shmsize, int *shmhdl)
{
    if(shmflag == 0)            //判断接口中共享内存key是否已经存在
    {
        shmkey = ftok(shmseedfile, 'c');
        if (shmkey == -1)
        {
            perror("ftok");
            return -1;
        }
            
        shmflag = 1;
    }
    
    //创建共享内存
    *shmhdl = shmget(shmkey,shmsize,IPC_CREAT|0666);
    if (*shmhdl == -1)            //创建失败
        return -2;
    return 0;

}
/***********************************************************************
  功能描述：    关联共享内存
  参数说明：    shmhdl    [in]  共享的句柄
                mapaddr [out] 共享内存首地址
  返回值：      返回0函数执行成功；非0返回错误码
************************************************************************/
int
IPC_MapShm(int  shmhdl, void  **mapaddr)
{
    void *tempptr = NULL;

    //连接共享内存
    tempptr = (void *)shmat(shmhdl,0,SHM_RND);
    if ((int)tempptr == -1)        //共享内存连接失败
        return -1;
    *mapaddr = tempptr;            //导出共享内存首指针

    return 0;
}
/***********************************************************************
  功能描述：    取消共享内存关联
  参数说明：    unmapaddr   [in] 共享内存首地址
  返回值：      返回0函数执行成功；非0返回错误码
************************************************************************/
int IPC_UnMapShm(void *unmapaddr)
{
    int  rv;
    //取消连接共享内存 
    rv = shmdt((char *)unmapaddr);
    if (rv == -1)            //取消连接失败
        return -1;

    return 0;
}
/***********************************************************************
  功能描述：    删除共享内存
  参数说明：    shmhdl    [in]  共享的句柄
  返回值：      返回0函数执行成功；非0返回错误码
************************************************************************/
int IPC_DelShm(int shmhdl)
{
    int  rv;
    //删除共享内存
    rv = shmctl(shmhdl,IPC_RMID,NULL);
    if(rv < 0)                //删除共享内存失败
        return -1;
    return 0;
}

客户端：

#include <unistd.h>
#include <sys/types.h>
//#include <sys/socket.h>
//#include <netinet/in.h>
//#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>
//#include "sckutil.h"

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#include "commsocket.h"

void handle(int signum)
{
    int pid = 0;
    printf("recv signum:%d 
", signum);
    
    //避免僵尸进程
    while ((pid = waitpid(-1, NULL, WNOHANG) ) > 0)
    {
        printf("退出子进程pid%d 
", pid);
        fflush(stdout);
    } 
}



int main()
{    
    int         ret = 0;
    void         *handle = NULL;
    //void         handle = NULL;
    int         connfd;
    int                 i = 0, j = 0;
    
    signal(SIGCHLD, handle);
    signal(SIGPIPE, SIG_IGN); //防止 sokcet破裂
    
    int procnum=10;
    int loopnum = 100;
    
    pthread_t tidArray[1024*2];
    


    printf("请输入要创建子进程的个数 : 
");
    scanf("%d", &procnum);

    printf("请输入让每个子进程测试多少次 :
");
    scanf("%d", &loopnum);
    
        
     unsigned char *data = (unsigned char *)"aaaaaafffffffffffssssss";
     int         datalen = 10;
     
     unsigned char out[1024];
     int outlen = 1024;
    //客户端环境初始化
    
    ret = sckCliet_init(&handle, 15, 5, 5, 10);

    for (i=0; i<procnum; i++)
    {
        int pid = fork();
        if (pid == 0)
        {
            ret = sckCliet_getconn(handle, "127.0.0.1", 8001, &connfd);
            for (j=0; j<loopnum; j++)
            {
                //客户端发送报文
                ret = sckClient_send(handle,  connfd, data, datalen);
                if (ret != 0)
                {
                    if (ret == Sck_ErrTimeOut)
                    {
                        continue;
                    }
                    break;
                }
                //printf("ccccccc
");
                    //客户端端接受报文
                ret = sckClient_rev(handle, connfd, out, &outlen); //10
                if (ret != 0)
                {
                    if (ret == Sck_ErrTimeOut)
                    {
                        break; 
                    }
                    break;
                }
                out[outlen] = '';
            
                printf("out: %s 
", out);
            }
            
            close(connfd);
            exit(0); //让子进程退出，不参与fork
        }
    }
    

    // 客户端环境释放 
    ret = sckClient_destroy(handle);
    
    //避免僵尸进程
    int mypid;
    while ((mypid = waitpid(-1, NULL, WNOHANG) ) > 0)
    {
        printf("退出子进程pid%d 
", mypid);
        fflush(stdout);
    } 

}

服务器：

#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/wait.h>


#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include "commsocket.h"

#include "myipc_sem.h"
#include "myipc_shm.h"
int g_key = 0x3333;

#define ERR_EXIT(m) 
        do 
        { 
                perror(m); 
                exit(EXIT_FAILURE); 
        } while(0)
        
        
#include <signal.h>

void handle(int signum)
{
    int pid = 0;
    printf("recv signum:%d 
", signum);
    
    //避免僵尸进程
    while ((pid = waitpid(-1, NULL, WNOHANG) ) > 0)
    {
        printf("退出子进程pid%d 
", pid);
        fflush(stdout);
    } 
}

int srvInit()
{
    //共享内存创建
    int        ret = 0;
    int     shmhdl = 0;
    ret = IPC_CreatShm(".", sizeof(int), &shmhdl);
    if (ret != 0)
    {
        printf("func IPC_CreatShm() err:%d 
", ret);
        return ret;
    }
    
    
    //信号量的创建
     int      semid = 0;
    ret = sem_creat(g_key, &semid);
    if (ret != 0)
    {
        printf("func sem_creat() err:%d,重新按照open打开信号量 
", ret);
        if (ret == SEMERR_EEXIST)
        {
            ret = sem_open(g_key, &semid);
            if (ret != 0)
            {
                printf("按照打开的方式，重新获取sem失败:%d 
", ret);
                return ret;
            }
        }
        else
        {
            return ret;
        }
        
    }
    
    int  val = 0;
    ret = sem_getval(semid, &val);
    if (ret != 0 )
    {
        printf("func sem_getval() err:%d 
", ret);
        return ret;
    }
    printf("sem val:%d
", val);
    
}


void TestFunc()
{
    int ncount = 0;
    int ret = 0;
    int shmhdl = 0;
    int *addr = NULL;
    
    int semid = 0;
    sem_open(g_key, &semid);


     sem_p(semid); //临界区开始
    //
        ret = IPC_CreatShm(".", 0, &shmhdl);
        
        ret =IPC_MapShm(shmhdl, (void **)&addr);
        *((int *)addr) =  *((int *)addr)  + 1;
        ncount = *((int *)addr);
        printf("ncount:%d
", ncount);
        //addr[0] = addr[0] +1;
        ret =IPC_UnMapShm(addr);
        //sleep(2);
        
    sem_v(semid);  //临界区开始
    //
    //printf("进程正常退出:%d
", getpid());
}    

int main(void)
{
    int        ret = 0;
    int     listenfd;
    
    
    signal(SIGCHLD, handle);
    signal(SIGPIPE, SIG_IGN);
    
    //完成共享内存和信号量的创建
    srvInit();
    //getchar();

    ret = sckServer_init(8001, &listenfd);
    if (ret != 0)
    {
        printf("sckServer_init() err:%d 
", ret);
        return ret;
    }
    
    while(1)
    {
        int ret = 0;
        int wait_seconds = 5;
        int connfd = 0;

        ret = sckServer_accept(listenfd, &connfd,  wait_seconds);
        if (ret == Sck_ErrTimeOut)
        {
            //printf("timeout....
");
            continue;
        }
    
        int pid = fork();
        if (pid == 0)
        {
            unsigned char     recvbuf[1024];
            int     recvbuflen = 1024;
                
            close(listenfd);
            while(1)
            {
                memset(recvbuf, 0, sizeof(recvbuf));
                ret = sckServer_rev(connfd, recvbuf, &recvbuflen,  wait_seconds);
                if (ret != 0)
                {
                    printf("func sckServer_rev() err:%d 
", ret);
                    break;
                }
                
                TestFunc();
                printf("recvbuf:%s
", recvbuf);
                
                //
                ret = sckServer_send(connfd,  recvbuf, recvbuflen, wait_seconds);
                if (ret != 0)
                {
                    printf("func sckServer_send() err:%d 
", ret);
                    break;
                }
            }
            close(connfd);
            exit(ret);
        }
        else if (pid > 0)
        {
            close(connfd);
        }
    }
    

    return 0;
}

服务器多线程框架：

客户端连接封装：

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

#include <fcntl.h>


#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#include "commsocket.h"

typedef struct _SckHandle
{
    int sockArray[100];
    int arrayNum;
    int sockfd;
    int contime;
    int sendtime;
    int revtime;

}SckHandle;

/**
 * readn - 读取固定字节数
 * @fd: 文件描述符
 * @buf: 接收缓冲区
 * @count: 要读取的字节数
 * 成功返回count，失败返回-1，读到EOF返回<count
 */
ssize_t readn(int fd, void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nread;
    char *bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nread = read(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
                continue;
            return -1;
        }
        else if (nread == 0)
            return count - nleft;

        bufp += nread;
        nleft -= nread;
    }

    return count;
}

/**
 * writen - 发送固定字节数
 * @fd: 文件描述符
 * @buf: 发送缓冲区
 * @count: 要读取的字节数
 * 成功返回count，失败返回-1
 */
ssize_t writen(int fd, const void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nwritten;
    char *bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
                continue;
            return -1;
        }
        else if (nwritten == 0)
            continue;

        bufp += nwritten;
        nleft -= nwritten;
    }

    return count;
}

/**
 * recv_peek - 仅仅查看套接字缓冲区数据，但不移除数据
 * @sockfd: 套接字
 * @buf: 接收缓冲区
 * @len: 长度
 * 成功返回>=0，失败返回-1
 */
ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while (1)
    {
        int ret = recv(sockfd, buf, len, MSG_PEEK);
        if (ret == -1 && errno == EINTR)
            continue;
        return ret;
    }
}


//函数声明
//客户端环境初始化
int sckCliet_init(void **handle, int contime, int sendtime, int revtime, int nConNum)
{
    int     ret = 0;
    if (handle == NULL ||contime<0 || sendtime<0 || revtime<0)
    {
        ret = Sck_ErrParam;
        printf("func sckCliet_init() err: %d, check  (handle == NULL ||contime<0 || sendtime<0 || revtime<0)
", ret);
        return ret;
    }
    
    SckHandle *tmp = (SckHandle *)malloc(sizeof(SckHandle));
    if (tmp == NULL)
    {
        ret = Sck_ErrMalloc;
        printf("func sckCliet_init() err: malloc %d
", ret);
        return ret;
    }
    
    tmp->contime = contime;
    tmp->sendtime = sendtime;
    tmp->revtime = revtime;
    tmp->arrayNum = nConNum;
        
        
    /*
    int sockfd;
    int i = 0;
    for (i=0; i<1; i++)
    {
        //链表的顺序
        sockfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (sockfd < 0)
        {
            ret = errno;
            printf("func socket() err:  %d
", ret);
            return ret;
        }
        tmp->sockfd = sockfd;
    }
    */

    *handle = tmp; 
    return ret;
}

/**
 * activate_noblock - 设置I/O为非阻塞模式
 * @fd: 文件描符符
 */
int activate_nonblock(int fd)
{
    int ret = 0;
    int flags = fcntl(fd, F_GETFL);
    if (flags == -1)
    {
        ret = flags;
        printf("func activate_nonblock() err:%d", ret);
        return ret;
    }
        

    flags |= O_NONBLOCK;
    ret = fcntl(fd, F_SETFL, flags);
    if (ret == -1)
    {
        printf("func activate_nonblock() err:%d", ret);
        return ret;
    }
    return ret;
}

/**
 * deactivate_nonblock - 设置I/O为阻塞模式
 * @fd: 文件描符符
 */
int deactivate_nonblock(int fd)
{
    int ret = 0;
    int flags = fcntl(fd, F_GETFL);
    if (flags == -1)
    {
        ret = flags;
        printf("func deactivate_nonblock() err:%d", ret);
        return ret;
    }

    flags &= ~O_NONBLOCK;
    ret = fcntl(fd, F_SETFL, flags);
    if (ret == -1)
    {
        printf("func deactivate_nonblock() err:%d", ret);
        return ret;
    }
    return ret;
}



/**
 * connect_timeout - connect
 * @fd: 套接字
 * @addr: 要连接的对方地址
 * @wait_seconds: 等待超时秒数，如果为0表示正常模式
 * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
 */
static int connect_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds)
{
    int ret;
    socklen_t addrlen = sizeof(struct sockaddr_in);

    if (wait_seconds > 0)
        activate_nonblock(fd);

    ret = connect(fd, (struct sockaddr*)addr, addrlen);
    if (ret < 0 && errno == EINPROGRESS)
    {
        //printf("11111111111111111111
");
        fd_set connect_fdset;
        struct timeval timeout;
        FD_ZERO(&connect_fdset);
        FD_SET(fd, &connect_fdset);
        timeout.tv_sec = wait_seconds;
        timeout.tv_usec = 0;
        do
        {
            // 一但连接建立，则套接字就可写  所以connect_fdset放在了写集合中
            ret = select(fd + 1, NULL, &connect_fdset, NULL, &timeout);
        } while (ret < 0 && errno == EINTR);
        if (ret == 0)
        {
            ret = -1;
            errno = ETIMEDOUT;
        }
        else if (ret < 0)
            return -1;
        else if (ret == 1)
        {
            //printf("22222222222222222
");
            /* ret返回为1（表示套接字可写），可能有两种情况，一种是连接建立成功，一种是套接字产生错误，*/
            /* 此时错误信息不会保存至errno变量中，因此，需要调用getsockopt来获取。 */
            int err;
            socklen_t socklen = sizeof(err);
            int sockoptret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &socklen);
            if (sockoptret == -1)
            {
                return -1;
            }
            if (err == 0)
            {
                //printf("3333333333333
");
                ret = 0;
            }
            else
            {
                //printf("4444444444444444:%d
", err);
                errno = err;
                ret = -1;
            }
        }
    }
    if (wait_seconds > 0)
    {
        deactivate_nonblock(fd);
    }
    return ret;
}



//
int sckCliet_getconn(void *handle, char *ip, int port, int *connfd)
{
    
    int ret = 0;
    SckHandle  *tmp = NULL;
    if (handle == NULL || ip==NULL || connfd==NULL || port<0 || port>65537)
    {
        ret = Sck_ErrParam;
        printf("func sckCliet_getconn() err: %d, check  (handle == NULL || ip==NULL || connfd==NULL || port<0 || port>65537) 
", ret);
        return ret;
    }
    
    //
    int sockfd;
    sockfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sockfd < 0)
    {
        ret = errno;
        printf("func socket() err:  %d
", ret);
        return ret;
    }
    
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(port);
    servaddr.sin_addr.s_addr = inet_addr(ip);
    
    tmp = (SckHandle* )handle;

    /*
    ret = connect(sockfd, (struct sockaddr*) (&servaddr), sizeof(servaddr));
    if (ret < 0)
    {
        ret = errno;
        printf("func connect() err:  %d
", ret);
        return ret;
    }
    */
    
    ret = connect_timeout(sockfd, (struct sockaddr_in*) (&servaddr), (unsigned int )tmp->contime);
    if (ret < 0)
    {
        if (ret==-1 && errno == ETIMEDOUT)
        {
            ret = Sck_ErrTimeOut;
            return ret;
        }
        else
        {
            printf("func connect_timeout() err:  %d
", ret);
        }
    }
    
    *connfd = sockfd;
   
       return ret;
    
}



/**
 * write_timeout - 写超时检测函数，不含写操作
 * @fd: 文件描述符
 * @wait_seconds: 等待超时秒数，如果为0表示不检测超时
 * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
 */
int write_timeout(int fd, unsigned int wait_seconds)
{
    int ret = 0;
    if (wait_seconds > 0)
    {
        fd_set write_fdset;
        struct timeval timeout;

        FD_ZERO(&write_fdset);
        FD_SET(fd, &write_fdset);

        timeout.tv_sec = wait_seconds;
        timeout.tv_usec = 0;
        do
        {
            ret = select(fd + 1, NULL, &write_fdset, NULL, &timeout);
        } while (ret < 0 && errno == EINTR);

        if (ret == 0)
        {
            ret = -1;
            errno = ETIMEDOUT;
        }
        else if (ret == 1)
            ret = 0;
    }

    return ret;
}


//客户端发送报文
int sckClient_send(void *handle, int  connfd,  unsigned char *data, int datalen)
{
    int     ret = 0;
    
    SckHandle  *tmp = NULL;
    tmp = (SckHandle *)handle;
    ret = write_timeout(connfd, tmp->sendtime);
    if (ret == 0)
    {
        int writed = 0;
        unsigned char *netdata = ( unsigned char *)malloc(datalen + 4);
        if ( netdata == NULL)
        {
            ret = Sck_ErrMalloc;
            printf("func sckClient_send() mlloc Err:%d
 ", ret);
            return ret;
        }
        int netlen = htonl(datalen);
        memcpy(netdata, &netlen, 4);
        memcpy(netdata+4, data, datalen);
        
        writed = writen(connfd, netdata, datalen + 4);
        if (writed < (datalen + 4) )
        {
            if (netdata != NULL) 
            {
                free(netdata);
                netdata = NULL;
            }
            return writed;
        }
          
    }
    
    if (ret < 0)
    {
        //失败返回-1，超时返回-1并且errno = ETIMEDOUT
        if (ret == -1 && errno == ETIMEDOUT)
        {
            ret = Sck_ErrTimeOut;
            printf("func sckClient_send() mlloc Err:%d
 ", ret);
            return ret;
        }
        return ret;
    }
    
    return ret;
}



/**
 * read_timeout - 读超时检测函数，不含读操作
 * @fd: 文件描述符
 * @wait_seconds: 等待超时秒数，如果为0表示不检测超时
 * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
 */
int read_timeout(int fd, unsigned int wait_seconds)
{
    int ret = 0;
    if (wait_seconds > 0)
    {
        fd_set read_fdset;
        struct timeval timeout;

        FD_ZERO(&read_fdset);
        FD_SET(fd, &read_fdset);

        timeout.tv_sec = wait_seconds;
        timeout.tv_usec = 0;
        
        //select返回值三态
        //1 若timeout时间到（超时），没有检测到读事件 ret返回=0
        //2 若ret返回<0 &&  errno == EINTR 说明select的过程中被别的信号中断（可中断睡眠原理）
        //2-1 若返回-1，select出错
        //3 若ret返回值>0 表示有read事件发生，返回事件发生的个数
        
        do
        {
            ret = select(fd + 1, &read_fdset, NULL, NULL, &timeout);
        } while (ret < 0 && errno == EINTR); 

        if (ret == 0)
        {
            ret = -1;
            errno = ETIMEDOUT;
        }
        else if (ret == 1)
            ret = 0;
    }

    return ret;
}

//客户端端接受报文
int sckClient_rev(void *handle,  int  connfd, unsigned char *out, int *outlen)
{
    
    int        ret = 0;
    SckHandle *tmpHandle = (SckHandle *)handle;
    
    if (handle==NULL || out==NULL)
    {
        ret = Sck_ErrParam;
        printf("func sckClient_rev() timeout , err:%d 
", Sck_ErrTimeOut);
        return ret;
    }
    
    ret =  read_timeout(connfd, tmpHandle->revtime ); //bugs modify bombing
    if (ret != 0)
    {
        if (ret==-1 || errno == ETIMEDOUT)
        {
            ret = Sck_ErrTimeOut;
            printf("func sckClient_rev() timeout , err:%d 
", Sck_ErrTimeOut);
            return ret;
        }
        else
        {
            printf("func sckClient_rev() timeout , err:%d 
", Sck_ErrTimeOut);
            return ret;
        }    
    }
    
    int netdatalen = 0;
    ret = readn(connfd, &netdatalen,  4); //读包头 4个字节
    if (ret == -1)
    {
        printf("func readn() err:%d 
", ret);
        return ret;
    }
    else if (ret < 4)
    {
        ret = Sck_ErrPeerClosed;
        printf("func readn() err peer closed:%d 
", ret);
        return ret;
    }
    
    int n;
    n = ntohl(netdatalen);
    ret = readn(connfd, out, n); //根据长度读数据
    if (ret == -1)
    {
        printf("func readn() err:%d 
", ret);
        return ret;
    }
    else if (ret < n)
    {
        ret = Sck_ErrPeerClosed;
        printf("func readn() err peer closed:%d 
", ret);
        return ret;
    }
    
    *outlen = n;
    
    return 0;
}

// 客户端环境释放 
int sckClient_destroy(void *handle)
{
    if (handle != NULL)
    {
        free(handle);
    }
    return 0;
}

int sckCliet_closeconn(int connfd)
{
    if (connfd >=0 )
    {
        close(connfd);
    }
    return 0;
}



/////////////////////////////////////////////////////////////////////////////////////
//函数声明
//服务器端初始化
int sckServer_init(int port, int *listenfd)
{
    int     ret = 0;
    int mylistenfd;
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(port);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    
        
    mylistenfd = socket(PF_INET, SOCK_STREAM, 0);
    if (mylistenfd < 0)
    {
        ret = errno ;
        printf("func socket() err:%d 
", ret);
        return ret;
    }
        

    int on = 1;
    ret = setsockopt(mylistenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) );
    if (ret < 0)
    {
        ret = errno ;
        printf("func setsockopt() err:%d 
", ret);
        return ret;
    }
    

    ret = bind(mylistenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
    if (ret < 0)
    {
        ret = errno ;
        printf("func bind() err:%d 
", ret);
        return ret;
    }
        
    ret = listen(mylistenfd, SOMAXCONN);
    if (ret < 0)
    {
        ret = errno ;
        printf("func listen() err:%d 
", ret);
        return ret;
    }
        
    *listenfd = mylistenfd;

    return 0;
}

/**
 * accept_timeout - 带超时的accept
 * @fd: 套接字
 * @addr: 输出参数，返回对方地址
 * @wait_seconds: 等待超时秒数，如果为0表示正常模式
 * 成功（未超时）返回已连接套接字，超时返回-1并且errno = ETIMEDOUT
 */
int accept_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds)
{
    int ret;
    socklen_t addrlen = sizeof(struct sockaddr_in);

    if (wait_seconds > 0)
    {
        fd_set accept_fdset;
        struct timeval timeout;
        FD_ZERO(&accept_fdset);
        FD_SET(fd, &accept_fdset);
        timeout.tv_sec = wait_seconds;
        timeout.tv_usec = 0;
        do
        {
            ret = select(fd + 1, &accept_fdset, NULL, NULL, &timeout);
        } while (ret < 0 && errno == EINTR);
        if (ret == -1)
            return -1;
        else if (ret == 0)
        {
            errno = ETIMEDOUT;
            return -1;
        }
    }

    //一但检测出 有select事件发生，表示对等方完成了三次握手，客户端有新连接建立
    //此时再调用accept将不会堵塞
    if (addr != NULL)
        ret = accept(fd, (struct sockaddr*)addr, &addrlen); //返回已连接套接字
    else
        ret = accept(fd, NULL, NULL);
        if (ret == -1)
        {
            ret = errno;
            printf("func accept() err:%d 
", ret);
            return ret;
        }
    

    return ret;
}

int sckServer_accept(int listenfd, int *connfd,  int timeout)
{
    int    ret = 0;
    
    ret = accept_timeout(listenfd, NULL, (unsigned int) timeout);
    if (ret < 0)
    {
        if (ret == -1 && errno == ETIMEDOUT)
        {
            ret = Sck_ErrTimeOut;
            //printf("func accept_timeout() timeout err:%d 
", ret);
            return ret;
        }
        else
        {
            ret = errno;
            printf("func accept_timeout() err:%d 
", ret);
            return ret;
        }
    }
    
    *connfd = ret;
    return 0;
}
//服务器端发送报文
int sckServer_send(int connfd,  unsigned char *data, int datalen, int timeout)
{
    int     ret = 0;
    
    ret = write_timeout(connfd, timeout);
    if (ret == 0)
    {
        int writed = 0;
        unsigned char *netdata = ( unsigned char *)malloc(datalen + 4);
        if ( netdata == NULL)
        {
            ret = Sck_ErrMalloc;
            printf("func sckServer_send() mlloc Err:%d
 ", ret);
            return ret;
        }
        int netlen = htonl(datalen);
        memcpy(netdata, &netlen, 4);
        memcpy(netdata+4, data, datalen);
        
        writed = writen(connfd, netdata, datalen + 4);
        if (writed < (datalen + 4) )
        {
            if (netdata != NULL) 
            {
                free(netdata);
                netdata = NULL;
            }
            return writed;
        }
          
    }
    
    if (ret < 0)
    {
        //失败返回-1，超时返回-1并且errno = ETIMEDOUT
        if (ret == -1 && errno == ETIMEDOUT)
        {
            ret = Sck_ErrTimeOut;
            printf("func sckServer_send() mlloc Err:%d
 ", ret);
            return ret;
        }
        return ret;
    }
    
    return ret;
}
//服务器端端接受报文
int sckServer_rev(int  connfd, unsigned char *out, int *outlen,  int timeout)
{
        
    int        ret = 0;
    
    if (out==NULL || outlen==NULL)
    {
        ret = Sck_ErrParam;
        printf("func sckClient_rev() timeout , err:%d 
", Sck_ErrTimeOut);
        return ret;
    }
    
    ret =  read_timeout(connfd, timeout); //bugs modify bombing
    if (ret != 0)
    {
        if (ret==-1 || errno == ETIMEDOUT)
        {
            ret = Sck_ErrTimeOut;
            printf("func sckClient_rev() timeout , err:%d 
", Sck_ErrTimeOut);
            return ret;
        }
        else
        {
            printf("func sckClient_rev() timeout , err:%d 
", Sck_ErrTimeOut);
            return ret;
        }    
    }
    
    int netdatalen = 0;
    ret = readn(connfd, &netdatalen,  4); //读包头 4个字节
    if (ret == -1)
    {
        printf("func readn() err:%d 
", ret);
        return ret;
    }
    else if (ret < 4)
    {
        ret = Sck_ErrPeerClosed;
        printf("func readn() err peer closed:%d 
", ret);
        return ret;
    }
    
    int n;
    n = ntohl(netdatalen);
    ret = readn(connfd, out, n); //根据长度读数据
    if (ret == -1)
    {
        printf("func readn() err:%d 
", ret);
        return ret;
    }
    else if (ret < n)
    {
        ret = Sck_ErrPeerClosed;
        printf("func readn() err peer closed:%d 
", ret);
        return ret;
    }
    
    *outlen = n;
    
    return 0;
}

//服务器端环境释放 
int sckServer_destroy(void *handle)
{
    return 0;
}

服务器：

#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/wait.h>


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

#include "commsocket.h"

#include "myipc_sem.h"
#include "myipc_shm.h"

pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;


int g_key = 0x3333;

#define ERR_EXIT(m) 
        do 
        { 
                perror(m); 
                exit(EXIT_FAILURE); 
        } while(0)
        
        
#include <signal.h>

void handle(int signum)
{
    int pid = 0;
    printf("recv signum:%d 
", signum);
    
    //避免僵尸进程
    while ((pid = waitpid(-1, NULL, WNOHANG) ) > 0)
    {
        printf("退出子进程pid%d 
", pid);
        fflush(stdout);
    } 
}

int srvInit()
{
    //共享内存创建
    int        ret = 0;
    int     shmhdl = 0;
    ret = IPC_CreatShm(".", sizeof(int), &shmhdl);
    if (ret != 0)
    {
        printf("func IPC_CreatShm() err:%d 
", ret);
        return ret;
    }
    
    
    //信号量的创建
     int      semid = 0;
    ret = sem_creat(g_key, &semid);
    if (ret != 0)
    {
        printf("func sem_creat() err:%d,重新按照open打开信号量 
", ret);
        if (ret == SEMERR_EEXIST)
        {
            ret = sem_open(g_key, &semid);
            if (ret != 0)
            {
                printf("按照打开的方式，重新获取sem失败:%d 
", ret);
                return ret;
            }
        }
        else
        {
            return ret;
        }
        
    }
    
    int  val = 0;
    ret = sem_getval(semid, &val);
    if (ret != 0 )
    {
        printf("func sem_getval() err:%d 
", ret);
        return ret;
    }
    printf("sem val:%d
", val);
    return 0;
    
}


void TestFunc_sem()
{
    int ncount = 0;
    int ret = 0;
    int shmhdl = 0;
    int *addr = NULL;
    
    int semid = 0;
    sem_open(g_key, &semid);


     sem_p(semid); //临界区开始
     
    //
        ret = IPC_CreatShm(".", 0, &shmhdl);
        
        ret =IPC_MapShm(shmhdl, (void **)&addr);
        *((int *)addr) =  *((int *)addr)  + 1;
        ncount = *((int *)addr);
        printf("ncount:%d
", ncount);
        //addr[0] = addr[0] +1;
        ret =IPC_UnMapShm(addr);
        //sleep(2);
        
    sem_v(semid);  //临界区开始
    //
    //printf("进程正常退出:%d
", getpid());
}    


void TestFunc_mutex()
{
    int ncount = 0;
    int ret = 0;
    int shmhdl = 0;
    int *addr = NULL;
    
    int semid = 0;
    sem_open(g_key, &semid);


     //sem_p(semid); //临界区开始
     pthread_mutex_lock(&mymutex);
     
    //
        ret = IPC_CreatShm(".", 0, &shmhdl);
        
        ret =IPC_MapShm(shmhdl, (void **)&addr);
        *((int *)addr) =  *((int *)addr)  + 1;
        ncount = *((int *)addr);
        printf("ncount:%d
", ncount);
        //addr[0] = addr[0] +1;
        ret =IPC_UnMapShm(addr);
        //sleep(2);
        
    //sem_v(semid);  //临界区开始
    pthread_mutex_unlock(&mymutex);
    //
    //printf("进程正常退出:%d
", getpid());
}    


void *thread_routine(void* arg)
{
    int     connfd = 0;
    int     ret = 0;
    
    pthread_detach(pthread_self());
    
    if (arg == NULL)
    {
        return NULL;
    }
    connfd = *((int *)arg);
    free(arg);

    unsigned char     recvbuf[1024];
    int         recvbuflen = 1024;
    int         wait_seconds = 5;
        
    
    while(1)
    {
        memset(recvbuf, 0, sizeof(recvbuf));
        ret = sckServer_rev(connfd, recvbuf, &recvbuflen,  wait_seconds);
        if (ret != 0)
        {
            if (ret == Sck_ErrTimeOut)
            {
                continue;
            }
            printf("func sckServer_rev() err:%d 
", ret);
            break;
        }
        
        TestFunc_mutex();
        printf("recvbuf:%s
", recvbuf);
        
        //
        ret = sckServer_send(connfd,  recvbuf, recvbuflen, wait_seconds);
        if (ret != 0)
        {
            printf("func sckServer_send() err:%d 
", ret);
            break;
        }
    }
    close(connfd);
    return NULL;    
}

int main(void)
{
    int        ret = 0;
    int     listenfd;
    
    
    signal(SIGCHLD, handle);
    signal(SIGPIPE, SIG_IGN);
    
    //完成共享内存和信号量的创建
    srvInit();

    ret = sckServer_init(8001, &listenfd);
    if (ret != 0)
    {
        printf("sckServer_init() err:%d 
", ret);
        return ret;
    }
    
    while(1)
    {
        int ret = 0;
        int wait_seconds = 5;
        int connfd = 0;

        ret = sckServer_accept(listenfd, &connfd,  wait_seconds);
        if (ret == Sck_ErrTimeOut)
        {
            //printf("timeout....
");
            continue;
        }
        int tid = 0;
        
        int *pCon = (int *)malloc(sizeof(int)) ; 
        *pCon = connfd;
        
        //每来一个连接，需要启动I个线程，线程需要收发报文 
        pthread_create(&tid, NULL, thread_routine, (void *)pCon);

    }
    

    return 0;
}

客户端：

#include <unistd.h>
#include <sys/types.h>
//#include <sys/socket.h>
//#include <netinet/in.h>
//#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>
//#include "sckutil.h"

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#include "commsocket.h"

void handle(int signum)
{
    int pid = 0;
    printf("recv signum:%d 
", signum);
    
    //避免僵尸进程
    while ((pid = waitpid(-1, NULL, WNOHANG) ) > 0)
    {
        printf("退出子进程pid%d 
", pid);
        fflush(stdout);
    } 
}



int main()
{    
    int         ret = 0;
    void         *handle = NULL;
    //void         handle = NULL;
    int         connfd;
    int                 i = 0, j = 0;
    
    signal(SIGCHLD, handle);
    signal(SIGPIPE, SIG_IGN); //防止 sokcet破裂
    
    int procnum=10;
    int loopnum = 100;
    
    pthread_t tidArray[1024*2];
    


    printf("请输入要创建子进程的个数 : 
");
    scanf("%d", &procnum);

    printf("请输入让每个子进程测试多少次 :
");
    scanf("%d", &loopnum);
    
        
     unsigned char *data = (unsigned char *)"aaaaaafffffffffffssssss";
     int         datalen = 10;
     
     unsigned char out[1024];
     int outlen = 1024;
    //客户端环境初始化
    
    ret = sckCliet_init(&handle, 15, 5, 5, 10);

    for (i=0; i<procnum; i++)
    {
        int pid = fork();
        if (pid == 0)
        {
            ret = sckCliet_getconn(handle, "127.0.0.1", 8001, &connfd);
            for (j=0; j<loopnum; j++)
            {
                //客户端发送报文
                ret = sckClient_send(handle,  connfd, data, datalen);
                if (ret != 0)
                {
                    if (ret == Sck_ErrTimeOut)
                    {
                        continue;
                    }
                    break;
                }
                //printf("ccccccc
");
                    //客户端端接受报文
                ret = sckClient_rev(handle, connfd, out, &outlen); //10
                if (ret != 0)
                {
                    if (ret == Sck_ErrTimeOut)
                    {
                        break; 
                    }
                    break;
                }
                out[outlen] = '';
            
                printf("out: %s 
", out);
            }
            
            close(connfd);
            exit(0); //让子进程退出，不参与fork
        }
    }
    

    // 客户端环境释放 
    ret = sckClient_destroy(handle);
    
    //避免僵尸进程
    int mypid;
    while ((mypid = waitpid(-1, NULL, WNOHANG) ) > 0)
    {
        printf("退出子进程pid%d 
", mypid);
        fflush(stdout);
    } 

}