• TCP 通信并发服务器详解（附有案例代码）

    一、多进程实现 TCP 通信并发服务器

    1、多进程实现通信并发服务器思路

    （1）一个父进程，多个子进程；

    （2）父进程负责等待并接受客户端的连接；

    （3）子进程：完成通信，接受一个客户端连接，就创建一个子进程用于通信。

    2、多进程实现通信并发服务器案例代码

    （1）客户端代码 client.c

    1. // TCP通信的客户端
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. int main() {
    9.  
    10.     // 1.创建套接字
    11.     int fd = socket(AF_INET, SOCK_STREAM, 0);
    12.     if(fd == -1) {
    13.         perror("socket");
    14.         exit(-1);
    15.     }
    16.  
    17.     // 2.连接服务器端
    18.     struct sockaddr_in serveraddr;
    19.     serveraddr.sin_family = AF_INET;
    20.     inet_pton(AF_INET, "192.168.172.128", &serveraddr.sin_addr.s_addr);         //对应自己电脑的IP地址
    21.     serveraddr.sin_port = htons(9999);
    22.     int ret = connect(fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
    23.  
    24.     if(ret == -1) {
    25.         perror("connect");
    26.         exit(-1);
    27.     }
    28.     
    29.     // 3. 通信
    30.     char recvBuf[1024];
    31.     int i = 0;
    32.     while(1) {
    33.         
    34.         sprintf(recvBuf, "data : %d\n", i++);
    35.         
    36.         // 给服务器端发送数据
    37.         write(fd, recvBuf, strlen(recvBuf)+1);          //+1是加上字符长结束字符
    38.  
    39.         int len = read(fd, recvBuf, sizeof(recvBuf));
    40.         if(len == -1) {
    41.             perror("read");
    42.             exit(-1);
    43.         } else if(len > 0) {
    44.             printf("recv server : %s\n", recvBuf);
    45.         } else if(len == 0) {
    46.             // 表示服务器端断开连接
    47.             printf("server closed...");
    48.             break;
    49.         }
    50.  
    51.         sleep(1);
    52.     }
    53.  
    54.     // 关闭连接
    55.     close(fd);
    56.  
    57.     return 0;
    58. }

    （2）服务端代码 server_process.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. void recyleChild(int arg) {
    11.     while(1) {
    12.         int ret = waitpid(-1, NULL, WNOHANG);
    13.         if(ret == -1) {
    14.             // 所有的子进程都回收了
    15.             break;
    16.         }else if(ret == 0) {
    17.             // 还有子进程活着
    18.             break;
    19.         } else if(ret > 0){
    20.             // 被回收了
    21.             printf("子进程 %d 被回收了\n", ret);
    22.         }
    23.     }
    24. }
    25.  
    26. int main() {
    27.  
    28.     struct sigaction act;
    29.     act.sa_flags = 0;
    30.     sigemptyset(&act.sa_mask);
    31.     act.sa_handler = recyleChild;
    32.  
    33.     // 注册信号捕捉，释放资源，此时不能用wait，该函数会阻塞影响通信
    34.     sigaction(SIGCHLD, &act, NULL);
    35.     
    36.  
    37.     // 创建socket
    38.     int lfd = socket(PF_INET, SOCK_STREAM, 0);
    39.     if(lfd == -1){
    40.         perror("socket");
    41.         exit(-1);
    42.     }
    43.  
    44.     struct sockaddr_in saddr;
    45.     saddr.sin_family = AF_INET;
    46.     saddr.sin_port = htons(9999);
    47.     saddr.sin_addr.s_addr = INADDR_ANY;
    48.  
    49.     // 绑定
    50.     int ret = bind(lfd,(struct sockaddr *)&saddr, sizeof(saddr));
    51.     if(ret == -1) {
    52.         perror("bind");
    53.         exit(-1);
    54.     }
    55.  
    56.     // 监听
    57.     ret = listen(lfd, 128);
    58.     if(ret == -1) {
    59.         perror("listen");
    60.         exit(-1);
    61.     }
    62.  
    63.     // 不断循环等待客户端连接
    64.     while(1) {
    65.  
    66.         struct sockaddr_in cliaddr;
    67.         int len = sizeof(cliaddr);
    68.         // 接受连接
    69.         int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len);
    70.         if(cfd == -1) {
    71.             if(errno == EINTR) {
    72.                 continue;
    73.             }
    74.             perror("accept");
    75.             exit(-1);
    76.         }
    77.  
    78.         // 每一个连接进来，创建一个子进程跟客户端通信
    79.         pid_t pid = fork();
    80.         if(pid == 0) {
    81.             // 子进程
    82.             // 获取客户端的信息
    83.             char cliIp[16];
    84.             inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, cliIp, sizeof(cliIp));
    85.             unsigned short cliPort = ntohs(cliaddr.sin_port);
    86.             printf("client ip is : %s, prot is %d\n", cliIp, cliPort);
    87.  
    88.             // 接收客户端发来的数据
    89.             char recvBuf[1024];
    90.             while(1) {
    91.                 int len = read(cfd, &recvBuf, sizeof(recvBuf));
    92.  
    93.                 if(len == -1) {
    94.                     perror("read");
    95.                     exit(-1);
    96.                 }else if(len > 0) {
    97.                     printf("recv client : %s\n", recvBuf);
    98.                 } else if(len == 0) {
    99.                     printf("client closed....\n");
    100.                     break;
    101.                 }
    102.                 write(cfd, recvBuf, strlen(recvBuf) + 1);
    103.             }
    104.             close(cfd);
    105.             exit(0);    // 退出当前子进程
    106.         }
    107.  
    108.     }
    109.     close(lfd);
    110.     return 0;
    111. }

    二、多线程实现 TCP 通信并发服务器 

    1、多进程实现通信并发服务器思路

    （1）一个父线程，多个子线程；

    （2）父线程负责等待并接受客户端的连接；

    （3）子线程：完成通信，接受一个客户端连接，就创建一个子线程用于通信。

    2、多线程实现通信并发服务器案例代码

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. struct sockInfo {
    9.     int fd; // 通信的文件描述符
    10.     struct sockaddr_in addr;
    11.     pthread_t tid;  // 线程号
    12. };
    13.  
    14. struct sockInfo sockinfos[128];
    15.  
    16. void * working(void * arg) {
    17.     // 子线程和客户端通信   cfd 客户端的信息 线程号
    18.     // 获取客户端的信息
    19.     struct sockInfo * pinfo = (struct sockInfo *)arg;
    20.  
    21.     char cliIp[16];
    22.     inet_ntop(AF_INET, &pinfo->addr.sin_addr.s_addr, cliIp, sizeof(cliIp));
    23.     unsigned short cliPort = ntohs(pinfo->addr.sin_port);
    24.     printf("client ip is : %s, prot is %d\n", cliIp, cliPort);
    25.  
    26.     // 接收客户端发来的数据
    27.     char recvBuf[1024];
    28.     while(1) {
    29.         int len = read(pinfo->fd, &recvBuf, sizeof(recvBuf));
    30.  
    31.         if(len == -1) {
    32.             perror("read");
    33.             exit(-1);
    34.         }else if(len > 0) {
    35.             printf("recv client : %s\n", recvBuf);
    36.         } else if(len == 0) {
    37.             printf("client closed....\n");
    38.             break;
    39.         }
    40.         write(pinfo->fd, recvBuf, strlen(recvBuf) + 1);
    41.     }
    42.     close(pinfo->fd);
    43.     return NULL;
    44. }
    45.  
    46. int main() {
    47.  
    48.     // 创建socket
    49.     int lfd = socket(PF_INET, SOCK_STREAM, 0);
    50.     if(lfd == -1){
    51.         perror("socket");
    52.         exit(-1);
    53.     }
    54.  
    55.     struct sockaddr_in saddr;
    56.     saddr.sin_family = AF_INET;
    57.     saddr.sin_port = htons(9999);
    58.     saddr.sin_addr.s_addr = INADDR_ANY;
    59.  
    60.     // 绑定
    61.     int ret = bind(lfd,(struct sockaddr *)&saddr, sizeof(saddr));
    62.     if(ret == -1) {
    63.         perror("bind");
    64.         exit(-1);
    65.     }
    66.  
    67.     // 监听
    68.     ret = listen(lfd, 128);
    69.     if(ret == -1) {
    70.         perror("listen");
    71.         exit(-1);
    72.     }
    73.  
    74.     // 初始化数据
    75.     int max = sizeof(sockinfos) / sizeof(sockinfos[0]);
    76.     for(int i = 0; i < max; i++) {
    77.         bzero(&sockinfos[i], sizeof(sockinfos[i]));
    78.         sockinfos[i].fd = -1;
    79.         sockinfos[i].tid = -1;
    80.     }
    81.  
    82.     // 循环等待客户端连接，一旦一个客户端连接进来，就创建一个子线程进行通信
    83.     while(1) {
    84.  
    85.         struct sockaddr_in cliaddr;
    86.         int len = sizeof(cliaddr);
    87.         // 接受连接
    88.         int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len);
    89.  
    90.         struct sockInfo * pinfo;
    91.         for(int i = 0; i < max; i++) {
    92.             // 从这个数组中找到一个可以用的sockInfo元素
    93.             if(sockinfos[i].fd == -1) {
    94.                 pinfo = &sockinfos[i];
    95.                 break;
    96.             }
    97.             if(i == max - 1) {
    98.                 sleep(1);
    99.                 i--;
    100.             }
    101.         }
    102.  
    103.         pinfo->fd = cfd;
    104.         memcpy(&pinfo->addr, &cliaddr, len);
    105.  
    106.         // 创建子线程
    107.         pthread_create(&pinfo->tid, NULL, working, pinfo);
    108.  
    109.         pthread_detach(pinfo->tid);
    110.     }
    111.  
    112.     close(lfd);
    113.     return 0;
    114. }

  • 相关阅读:
    【补题日记】[2022牛客暑期多校4]A-Task Computing
    如何监听电脑屏幕是否发生切换
    PAT 甲级常见单词整理
    【seata】引入seata导致原本自定义实现的RequestInterceptor失效
    无痛入门Prometheus：一个强大的开源监控和告警系统，如何快速安装和使用？
    传输层之UDP协议
    【Java面试】第三章：P6级面试
    PTA：7-3 两个递增链表的差集
    html网页如何获取后台数据库的数据(html + ajax + php + mysql)
    day 1
  • 原文地址：https://blog.csdn.net/weixin_47156401/article/details/125868728