基于Linux socket聊天室-多线程服务器模型大全

Myth丶恋晨 2022-12-21 03:29 215阅读 0赞

Socket在实际系统程序开发当中，应用非常广泛，也非常重要。实际应用中服务器经常需要支持多个客户端连接，实现高并发服务器模型显得尤为重要。高并发服务器从简单的循环服务器模型处理少量网络并发请求，演进到解决C10K，C10M问题的高并发服务器模型。本文通过一个简单的多线程模型，带领大家学习如何自己实现一个简单的并发服务器。

## C/S架构 ##

服务器-客户机，即Client-Server(C/S)结构。C/S结构通常采取两层结构。服务器负责数据的管理，客户机负责完成与用户的交互任务。  
在C/S结构中，应用程序分为两部分:服务器部分和客户机部分。服务器部分是多个用户共享的信息与功能，执行后台服务，如控制共享数据库的操作等;客户机部分为用户所专有，负责执行前台功能，在出错提示、在线帮助等方面都有强大的功能，并且可以在子程序间自由切换。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center]

如上图所示：这是基于套接字实现客户端和服务器相连的函数调用关系，socket API资料比较多，本文不再过多叙述。

## pthread线程库:(POSIX) ##

pthread线程库是Linux下比较常用的一个线程库，关于他的用法和特性大家可以自行搜索相关文章，下面只简单介绍他的用法和编译。

**线程标识**  
线程有ID, 但不是系统唯一, 而是进程环境中唯一有效. 线程的句柄是pthread\_t类型, 该类型不能作为整数处理, 而是一个结构. 下面介绍两个函数:

头文件: <pthread.h>  
原型: int pthread\_equal(pthread\_t tid1, pthread\_t tid2);  
返回值: 相等返回非0, 不相等返回0.  
说明: 比较两个线程ID是否相等.

头文件: <pthread.h>  
原型: pthread\_t pthread\_self();  
返回值: 返回调用线程的线程ID.

**线程创建**  
在执行中创建一个线程, 可以为该线程分配它需要做的工作(线程执行函数), 该线程共享进程的资源. 创建线程的函数pthread\_create()

头文件: <pthread.h>  
原型: int pthread\_create(pthread\_t \*restrict tidp, const pthread\_attr\_t \*restrict attr, void \*(start\_rtn)(void), void \*restrict arg);  
返回值: 成功则返回0, 否则返回错误编号.  
参数:  
tidp: 指向新创建线程ID的变量, 作为函数的输出.  
attr: 用于定制各种不同的线程属性, NULL为默认属性（见下）.  
start\_rtn: 函数指针, 为线程开始执行的函数名.该函数可以返回一个void \*类型的返回值，  
而这个返回值也可以是其他类型，并由 pthread\_join()获取  
arg: 函数的唯一无类型(void)指针参数, 如要传多个参数, 可以用结构封装.

**编译**

因为pthread的库不是linux系统的库，所以在进行编译的时候要加上 -lpthread

# gcc filename -lpthread  //默认情况下gcc使用c库，要使用额外的库要这样选择使用的库`

**需要C/C++ Linux服务器架构师学习资料加群812855908（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等）**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 1]

## 常见的网络服务器模型 ##

本文结合自己的理解，主要以TCP为例，总结了几种常见的网络服务器模型的实现方式，并最终实现一个简单的命令行聊天室。

**单进程循环**

单线进程循环原理就是主进程没和客户端通信，客户端都要先连接服务器，服务器接受一个客户端连接后从客户端读取数据，然后处理并将处理的结果返还给客户端，然后再接受下一个客户端的连接请求。

优点单线程循环模型优点是简单、易于实现，没有同步、加锁这些麻烦事，也没有这些开销。

缺点

*  阻塞模型，网络请求串行处理；
 *  没有利用多核cpu的优势，网络请求串行处理；
 *  无法支持同时多个客户端连接；
 *  程序串行操作，服务器无法实现同时收发数据。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 2]  
    **单线程IO复用**

linux高并发服务器中常用epoll作为IO复用机制。线程将需要处理的socket读写事件都注册到epoll中，当有网络IO发生时，epoll\_wait返回，线程检查并处理到来socket上的请求。

优点

*  实现简单， 减少锁开销，减少线程切换开销。

缺点

*  只能使用单核cpu，handle时间过长会导致整个服务挂死；
 *  当有客户端数量超过一定数量后，性能会显著下降；
 *  只适用高IO、低计算，handle处理时间短的场景。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 3]  
    **多线程/多进程**

多线程、多进程模型主要特点是每个网络请求由一个进程/线程处理，线程内部使用阻塞式系统调用，在线程的职能划分上，可以由一个单独的线程处理accept连接，其余线程处理具体的网络请求（收包，处理，发包）；还可以多个进程单独listen、accept网络连接。

优点：

*  实现相对简单；
 *  利用到CPU多核资源。

缺点：

*  线程内部还是阻塞的，举个极端的例子，如果一个线程在handle的业务逻辑中sleep了，这个线程也就挂住了。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 4]  
    **多线程/多进程IO复用**

多线程、多进程IO服用模型，每个子进程都监听服务，并且都使用epoll机制来处理进程的网络请求，子进程 accept() 后将创建已连接描述符，然后通过已连接描述符来与客户端通信。该机制适用于高并发的场景。

优点：

*  支撑较高并发。

缺点：

*  异步编程不直观、容易出错  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 5]  
    **多线程划分IO角色**

多线程划分IO角色主要功能有：一个accept thread处理新连接建立；一个IO thread pool处理网络IO；一个handle thread pool处理业务逻辑。使用场景如：电销应用，thrift TThreadedSelectorServer。

优点：

*  按不同功能划分线程，各线程处理固定功能，效率更高
 *  可以根据业务特点配置线程数量来性能调优

缺点：

*  线程间通信需要引入锁开销
 *  逻辑较复杂，实现难度大  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 6]  
    **小结**

上面介绍了常见的网络服务器模型，还有AIO、协程，甚至还有其他的变型，在这里不再讨论。重要的是理解每种场景中所面临的问题和每种模型的特点，设计出符合应用场景的方案才是好方案。

## 多线程并发服务器模型 ##

下面我们主要讨论多线程并发服务器模型。

**代码结构**

并发服务器代码结构如下：

thread_func()
    { 
      while(1) { 
        recv(...);
        process(...);
        send(...);
      }
      close(...);
    }
    main(
     socket(...); 
     bind(...);
     listen(...);
     while(1) {  
      accept(...);
      pthread_create();
     }
    }

由上可以看出，服务器分为两部分：主线程、子线程。

**主线程**  
main函数即主线程，它的主要任务如下：

*  socket()创建监听套字；
 *  bind（）绑定端口号和地址；
 *  listen（）开启监听；
 *  accept（）等待客户端的连接，
 *  当有客户端连接时，accept（）会创建一个新的套接字new\_fd；
 *  主线程会创建子线程，并将new\_fd传递给子线程。

**子线程**

*  子线程函数为thread\_func（），他通过new\_fd处理和客户端所有的通信任务。

**客户端连接服务器详细步骤**  
下面我们分步骤来看客户端连接服务器的分步说明。

**1. 客户端连接服务器**

*  服务器建立起监听套接字listen\_fd，并初始化；
 *  客户端创建套接字fd1；
 *  客户端client1通过套接字fd1连接服务器的listen\_fd；  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 7]  
    **2. 主线程创建子线程thread1**
 *  server收到client1的连接请求后，accpet函数会返回一个新的套接字newfd1;
 *  后面server与client1的通信就依赖newfd1，监听套接字listen\_fd会继续监听其他客户端的连接；
 *  主线程通过pthead\_create()创建一个子线程thread1，并把newfd1传递给thread1；
 *  server与client1的通信就分别依赖newfd1、fd1。
 *  client1为了能够实时收到server发送的信息，同时还要能够从键盘上读取数据，这两个操作都是阻塞的，没有数据的时候进程会休眠，所以必须创建子线程read\_thread;
 *  client1的主线负责从键盘上读取数据并发送给，子线程read\_thread负责从server接受信息。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 8]  
    **3. client2连接服务器**
 *  客户端client2创建套接字fd2;
 *  通过connect函数连接server的listen\_fd；  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 9]  
    **4. 主线程创建子线程thread2**
 *  server收到client2的连接请求后，accpet函数会返回一个新的套接字newfd2;
 *  后面server与client2的通信就依赖newfd2，监听套接字listen\_fd会继续监听其他客户端的连接；
 *  主线程通过pthead\_create()创建一个子线程thread2，并把newfd2传递给thread2；
 *  server与client1的通信就分别依赖newfd2、fd2。
 *  同样client2为了能够实时收到server发送的信息，同时还要能够从键盘上读取数据必须创建子线程read\_thread;
 *  client1的主线负责从键盘上读取数据并发送给，子线程read\_thread负责从server接受信息。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 10]  
    由上图可见，每一个客户端连接server后，server都要创建一个专门的thread负责和该客户端的通信；每一个客户端和server都有一对固定的fd组合用于连接。

## 实例 ##

好了，理论讲完了，根据一口君的惯例，也继承祖师爷的教诲：talk is cheap，show you my code.不上代码，只写理论的文章都是在耍流氓。

本例的主要功能描述如下：

1、实现多个客户端可以同时连接服务器；  
2、客户端可以实现独立的收发数据；  
3、客户端发送数据给服务器后，服务器会将数据原封不动返回给客户端。

**服务器端**

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <errno.h>
    #include <string.h>
    #include <pthread.h>
    #include <stdlib.h>
    
    #define RECVBUFSIZE 2048
    void *rec_func(void *arg)
    { 
     int sockfd,new_fd,nbytes;
     char buffer[RECVBUFSIZE];
     int i;
     new_fd = *((int *) arg);
     free(arg); 
     
     while(1)
     { 
      if((nbytes=recv(new_fd,buffer, RECVBUFSIZE,0))==-1)
      { 
       fprintf(stderr,"Read Error:%s\n",strerror(errno));
       exit(1);
      }
      if(nbytes == -1)
      { //客户端出错了 返回值-1
       close(new_fd);
       break;   
      }
      if(nbytes == 0)
      { //客户端主动断开连接，返回值是0
       close(new_fd);
       break;
      }
      buffer[nbytes]='\0'; 
      printf("I have received:%s\n",buffer); 
      
      
      if(send(new_fd,buffer,strlen(buffer),0)==-1)
      { 
       fprintf(stderr,"Write Error:%s\n",strerror(errno));
       exit(1);
      }
       
     }
    
    }
    
    int main(int argc, char *argv[])
    { 
     char buffer[RECVBUFSIZE];
     int sockfd,new_fd,nbytes;
     struct sockaddr_in server_addr;
     struct sockaddr_in client_addr;
     int sin_size,portnumber;
     char hello[]="Hello! Socket communication world!\n";
     pthread_t tid;
     int *pconnsocke = NULL;
     int ret,i;
     
     if(argc!=2)
     { 
      fprintf(stderr,"Usage:%s portnumber\a\n",argv[0]);
      exit(1);
     }
     /*端口号不对，退出*/
     if((portnumber=atoi(argv[1]))<0)
     { 
      fprintf(stderr,"Usage:%s portnumber\a\n",argv[0]);
      exit(1);
     }
    
     /*服务器端开始建立socket描述符 sockfd用于监听*/
     if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)  
     { 
      fprintf(stderr,"Socket error:%s\n\a",strerror(errno));
      exit(1);
     }
     
     /*服务器端填充 sockaddr结构*/ 
     bzero(&server_addr,sizeof(struct sockaddr_in));
     server_addr.sin_family     =AF_INET;
     /*自动填充主机IP*/
     server_addr.sin_addr.s_addr=htonl(INADDR_ANY);//自动获取网卡地址
     server_addr.sin_port       =htons(portnumber);
     
     /*捆绑sockfd描述符*/ 
     if(bind(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1)
     { 
      fprintf(stderr,"Bind error:%s\n\a",strerror(errno));
      exit(1);
     }
     
     /*监听sockfd描述符*/
     if(listen(sockfd, 10)==-1)
     { 
      fprintf(stderr,"Listen error:%s\n\a",strerror(errno));
      exit(1);
     }
    
     while(1)
     { 
      /*服务器阻塞，直到客户程序建立连接*/
      sin_size=sizeof(struct sockaddr_in);
      if((new_fd = accept(sockfd,(struct sockaddr *)&client_addr,&sin_size))==-1)
      { 
       fprintf(stderr,"Accept error:%s\n\a",strerror(errno));
       exit(1);
      }
      
      pconnsocke = (int *) malloc(sizeof(int));
      *pconnsocke = new_fd;
      
      ret = pthread_create(&tid, NULL, rec_func, (void *) pconnsocke);
      if (ret < 0) 
      { 
       perror("pthread_create err");
       return -1;
      } 
     }
     //close(sockfd);
     exit(0);
    }

**客户端**

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <errno.h>
    #include <string.h>
    #include <pthread.h>
    #include <stdlib.h>
    #define RECVBUFSIZE 1024
    
    void *func(void *arg)
    { 
     int sockfd,new_fd,nbytes;
     char buffer[RECVBUFSIZE];
     
     new_fd = *((int *) arg);
     free(arg);
     
     while(1)
     { 
      if((nbytes=recv(new_fd,buffer, RECVBUFSIZE,0))==-1)
      { 
       fprintf(stderr,"Read Error:%s\n",strerror(errno));
       exit(1);
      }
      buffer[nbytes]='\0';
      printf("I have received:%s\n",buffer); 
     }
    
    }
    
    int main(int argc, char *argv[])
    { 
     int sockfd;
     char buffer[RECVBUFSIZE];
     struct sockaddr_in server_addr;
     struct hostent *host;
     int portnumber,nbytes; 
     pthread_t tid;
     int *pconnsocke = NULL;
     int ret;
     
     //检测参数个数
     if(argc!=3)
     { 
      fprintf(stderr,"Usage:%s hostname portnumber\a\n",argv[0]);
      exit(1);
     }
     //argv2 存放的是端口号 ，读取该端口，转换成整型变量
     if((portnumber=atoi(argv[2]))<0)
     { 
      fprintf(stderr,"Usage:%s hostname portnumber\a\n",argv[0]);
      exit(1);
     }
     //创建一个 套接子
     if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
     { 
      fprintf(stderr,"Socket Error:%s\a\n",strerror(errno));
      exit(1);
     }
    
     //填充结构体，ip和port必须是服务器的
     bzero(&server_addr,sizeof(server_addr));
     server_addr.sin_family=AF_INET;
     server_addr.sin_port=htons(portnumber);
     server_addr.sin_addr.s_addr = inet_addr(argv[1]);//argv【1】 是server ip地址
    
     /*¿Í»§³ÌÐò·¢ÆðÁ¬œÓÇëÇó*/ 
     if(connect(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1)
     { 
      fprintf(stderr,"Connect Error:%s\a\n",strerror(errno));
      exit(1);
     }
     
     //创建线程
     pconnsocke = (int *) malloc(sizeof(int));
     *pconnsocke = sockfd;
     
     ret = pthread_create(&tid, NULL, func, (void *) pconnsocke);
     if (ret < 0) 
     { 
      perror("pthread_create err");
      return -1;
     } 
     while(1)
     { 
     #if 1
      printf("input msg:");
      scanf("%s",buffer);
      if(send(sockfd,buffer,strlen(buffer),0)==-1)
      { 
       fprintf(stderr,"Write Error:%s\n",strerror(errno));
       exit(1);
      }
      #endif
     }
     close(sockfd);
     exit(0);
    }

编译编译线程，需要用到pthread库，编译命令如下：

gcc s.c -o s -lpthread  
gcc cli.c -o c -lpthread 先本机测试  
开启一个终端 ./s 8888  
再开一个终端 ./cl 127.0.0.1 8888,输入一个字符串"qqqqqqq"  
再开一个终端 ./cl 127.0.0.1 8888,输入一个字符串"yikoulinux"  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 11]  
有读者可能会注意到，server创建子线程的时候用的是以下代码：

pconnsocke = (int *) malloc(sizeof(int));
      *pconnsocke = new_fd;
      
      ret = pthread_create(&tid, NULL, rec_func, (void *) pconnsocke);
      if (ret < 0) 
      { 
       perror("pthread_create err");
       return -1;
      }

为什么必须要malloc一块内存专门存放这个新的套接字呢？ 这个是一个很隐蔽，很多新手都容易犯的错误。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/09a254d7eb2f43ff90aacbbea69aca23.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/d080dbe8e41041339306b5b0af3ddb6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/a21606f8e3964b068f8f62469c76f25f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/6d4a875da12e4c0cb951cfb6096b5de1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/befec5a2b68a42c9bb12434005a43e8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/0abba6fe6d87406899d5b0898927d9dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/9ac95af8d305412f8c61d22f30093048.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221120/cc422cc408994bcc891bd3283c4cc8a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221120/a71975ef88f14527ae019773c7fe40d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221120/4cfe7a311b4e48308337c056597ce12f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221120/023f047a6d4c4644a22f140350856ee9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221120/6453e32171554953824652640fe5ff48.png