cs模式多进程多线程通信

多进程

Client：创建套接字，连接服务器，通信

Server：创建套接字，绑定，监听，接收，创建子进程，通信

信号机制

• struct sigaction

  struct sigaction {
      void (*sa_handler)(int);//信号处理函数
      void (*sa_sigaction)(int, siginfo_t *, void *);
      sigset_t sa_mask;	//搁置的信号集
      int sa_flags;		//信号处理的其他相关操作，
  //SA_RESETHAND：当调用信号处理函数时，将信号的处理函数重置为缺省值SIG_DFL					
  //SA_RESTART：如果信号中断了进程的某个系统调用，则系统自动启动该系统调用
  //SA_NODEFER ：一般情况下，当信号处理函数运行时，内核将阻塞该给定信号。但是如果设置了SA_NODEFER标记，那么在该信号处理函数运行时，内核将不会阻塞该信号
      void (*sa_restorer)(void);
  }
  

• sigaction函数

  int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
  	- 功能:检查或修改与指定信号相关联的处理动作,可同时两种操作
      - 参数:
          - signum：捕获信号的类型
          - act: 指定新的信号处理方式
          - oldact：输出老的信号处理方式
  

多线程

Client：创建套接字，连接服务器，通信

Server：创建套接字，绑定，监听，接收，创建子线程，通信

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
	- 功能：创建线程
    - 返回值：成功：0，失败：错误号
    - 参数：
        -thread:传出参数，保存系统为我们分配好的线程ID
        -attr:通常传NULL，表示使用线程默认属性。若想使用具体属性也可以修改该参数。
        -start_routine:函数指针，指向线程主函数(线程体)，该函数运行结束，则线程结束。
        -arg:线程主函数执行期间所使用的参数，如要传多个参数, 可以用结构封装。

pthread_t pthread_self(void);
	- 功能：获取线程号
    - 返回值：线程号
    - 参数：
int pthread_equal(pthread_t t1, pthread_t t2);
	- 功能：
    - 返回值：
    - 参数：
void pthread_exit(void *retval);//自身调用
	- 功能：将单个线程退出
    - 返回值：
    - 参数：一般为null
int pthread_join(pthread_t thread, void **retval);
	- 功能：阻塞等待线程退出，获取线程退出状态
    - 返回值：成功：0，失败：错误号
    - 参数：
        -thread：线程号
        - retval：存储线程结束状态
int pthread_detach(pthread_t thread);//网络、多线程服务器常用
	- 功能：线程分离
    - 返回值：成功：0，失败：错误号
    - 参数：
        - thread：线程号
int pthread_cancel(pthread_t thread);//同一进程，线程可调用杀死其他线程
	- 功能：杀死(取消)线程
    - 返回值：成功：0，失败：错误号
    - 参数：
        - thread：线程号

服务器端：

#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
struct sockInfo {
    int fd; // 通信的文件描述符
    struct sockaddr_in addr;
    pthread_t tid;  // 线程号
};
struct sockInfo sockinfos[128];
void * working(void * arg) {
    // 子线程和客户端通信   cfd 客户端的信息 线程号
    // 获取客户端的信息
    struct sockInfo * pinfo = (struct sockInfo *)arg;
    char cliIp[16];
    inet_ntop(AF_INET, &pinfo->addr.sin_addr.s_addr, cliIp, sizeof(cliIp));
    unsigned short cliPort = ntohs(pinfo->addr.sin_port);
    printf("client ip is : %s, prot is %d\n", cliIp, cliPort);
    // 接收客户端发来的数据
    char recvBuf[1024];
    while(1) {
        int len = read(pinfo->fd, &recvBuf, sizeof(recvBuf));

        if(len == -1) {
            perror("read");
            exit(-1);
        }else if(len > 0) {
            printf("recv client : %s\n", recvBuf);
        } else if(len == 0) {
            printf("client closed....\n");
            break;
        }
        write(pinfo->fd, recvBuf, strlen(recvBuf) + 1);
    }
    close(pinfo->fd);
    return NULL;
}
int main() {
    // 创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    if(lfd == -1){
        perror("socket");
        exit(-1);
    }
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    saddr.sin_addr.s_addr = INADDR_ANY;//0.0.0.0
    // 绑定
    int ret = bind(lfd,(struct sockaddr *)&saddr, sizeof(saddr));
    if(ret == -1) {
        perror("bind");
        exit(-1);
    }
    // 监听
    ret = listen(lfd, 128);//最多监听128个
    if(ret == -1) {
        perror("listen");
        exit(-1);
    }
    // 初始化数据
    int max = sizeof(sockinfos) / sizeof(sockinfos[0]);//128
    for(int i = 0; i < max; i++) {
        bzero(&sockinfos[i], sizeof(sockinfos[i]));//前n个字节清零，仅linux gcc支持
        //memset(&sockinfos[i], 0, sizeof(sockinfos[i]))
        sockinfos[i].fd = -1;//文件描述符置-1
        sockinfos[i].tid = -1;//线程号置-1
    }
    // 循环等待客户端连接，一旦一个客户端连接进来，就创建一个子线程进行通信
    while(1) {
        struct sockaddr_in cliaddr;
        int len = sizeof(cliaddr);
        // 接受连接
        int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len);//等待
        if(cfd == -1) {
            if(errno == EINTR) {
                continue;
            }
            perror("accept");
            exit(-1);
        }
        struct sockInfo *pinfo;
        for(int i = 0; i < max; i++) {
            // 从这个数组中找到一个可以用的sockInfo元素
            if(sockinfos[i].fd == -1) {//-1说明线程可用
                pinfo = &sockinfos[i];
                break;
            }
            if(i == max - 1) {
                sleep(1);
                i--;
            }
        }
        pinfo->fd = cfd;
        memcpy(&pinfo->addr, &cliaddr, len);//将client的地址信息复制到pinfo->addr

        // 创建子线程
        pthread_create(&pinfo->tid, NULL, working, pinfo);

        pthread_detach(pinfo->tid);
    }
    close(lfd);
    return 0;
}

源码地址：https://gitee.com/iGangao/PersonalStudy