关于多路IO写服务器和使用多线程、多进程写服务器的区别（简单理解）

最新推荐文章于 2021-11-23 08:44:00 发布
最新推荐文章于 2021-11-23 08:44:00 发布
阅读量1.5k 收藏 11
点赞数 4
分类专栏： linux系统编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lailaiquququ11/article/details/83067240
版权

那这篇博客主要是承接上面的poll  select  epoll的区别，上升到多线程、多进程和高级IO复用的区别了。

https://blog.csdn.net/lailaiquququ11/article/details/83066593

那我们还是从代码开始说起，先看看，简单的多线程和多进程的代码，然后在进行补充说明：

使用多线程和多进程也能够实现多个客户端和服务器的数据收发的功能。那么所有的监听连接请求和请求的接受处理都会由服务器来处理，即用户自定义的程序来处理（就是我们自己编写的server.c的代码了），这在大型的项目，是极其不推荐的，它不仅降低了程序执行的效率，而且还占用了大量的CPU资源（即accept去监听）。

用户的应用来处理。若使用多路I/O转接，那么 这里关于监听和连接的不再是由用户自己处理，取而代之由内核应用程序监视文件。（即把内核请过来当帮手，来监听相应的客户端，当内核接受客户端的连接请求，给应用程序（server.c）一个反馈，然后应用程序立即与客户端建立连接(不需要再去accept()等待，此部分为链接的部分)，然后把它继续放到内核里面去监听，当再次反馈给应用程序的时候，就是有数据过来需要读取了（就不在需要read()的等待）。不然应用程序会在accept()，read()部分会被阻塞。这里使用这种机制，可以当有这些事件发生了，应用程序才去处理，这就空出了很多的时间，不再是阻塞，应用程序可以去干其他的事情。整个机制类似于signal()的功能）

内核反馈的时候是一定有事件发生了，具体是什么事件，建立连接，读事件或者写事件，应用程序处理的时候就需要去具体区分。

这就是使用整个多路IO与多进程多线程的简单区别。

 

1、多进程并发服务器

使用多进程并发服务器时要考虑以下几点：

  1. 父进程最大文件描述个数(父进程中需要close关闭accept返回的新文件描述符)
  2. 系统内创建进程个数(与内存大小相关)
  3. 进程创建过多是否降低整体服务性能(进程调度)

 

2、多线程并发服务器

在使用线程模型开发服务器时需考虑以下问题：

  1. 调整进程内最大文件描述符上限
  2. 线程如有共享数据，考虑线程同步
  3. 服务于客户端线程退出时，退出处理。（退出值，分离态）
  4. 系统负载，随着链接客户端增加，导致其它线程不能及时得到CPU

 

3、多路I/O转接服务器

多路IO转接服务器也叫做多任务IO服务器。该类服务器实现的主旨思想是，不再由应用程序自己监视客户端连接，取而代之由内核替应用程序监视文件。

主要使用的方法有三种

select、poll、epoll

 

多进程服务器：


#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <pthread.h>
#include <signal.h>

#define       SER_PORT     7777
#define       SIZE         1024

static pthread_rwlock_t   rw;

struct node{
    char   ip[16];
    int    sfd;
    struct node *next,*prev;
}head={.next=&head,.prev=&head};
int appendList(int sfd,char *ip);
void deleteList(int sfd);
/
int initSocket(void);
void *listenMsg(void *arg);

int main(void)
{
     pthread_t tid;
     long   ret,newsfd,sockfd;
     struct sockaddr_in   peer;
     socklen_t   len=sizeof(peer);
     char buf[SIZE+32];
     struct node *i;
     
     signal(SIGPIPE,SIG_IGN);//!!!!!!!!!!!!!!!!!!!!!

     if(pthread_rwlock_init(&rw,NULL)!=0)
     {
         fprintf(stderr,"init rwlock failed.\n");
         return 2;
     }

     sockfd=initSocket();
     if(sockfd<0)   return 1;

     printf("server start success.\n");
     while(1)
     {
        newsfd=accept(sockfd,(struct sockaddr *)&peer,&len);
        if(newsfd==-1)  continue;//failed

pthread_rwlock_wrlock(&rw);
        //记录连接者的套接字  便于转发
        ret=appendList(newsfd,inet_ntoa(peer.sin_addr));
        if(ret!=0)
        {
           send(newsfd,"服务器:\n  无法进入聊天室.\n",strlen("服务器:\n  无法进入聊天室.\n"),0);
           shutdown(newsfd,SHUT_RDWR);
           continue;
        }
        //新建线程
        ret=pthread_create(&tid,NULL,listenMsg,(void *)newsfd);
        if(ret!=0)
        {
           deleteList(newsfd);
           send(newsfd,"服务器:\n  无法进入聊天室.\n",strlen("服务器:\n  无法进入聊天室.\n"),0);
           shutdown(newsfd,SHUT_RDWR);
        }
        //
        snprintf(buf,SIZE,"[服务器]:\n  欢迎 %s 进入聊天室!\n",inet_ntoa(peer.sin_addr));
        for(i=head.next;i!=&head;i=i->next)
        {
            send(i->sfd,buf,strlen(buf),0);
        } 
pthread_rwlock_unlock(&rw);
     }
     return 0;
}
void *listenMsg(void *arg)
{
     long   ret,len,sfd=(long)arg;
     char   buf[SIZE+32];
     struct node  *i,*my;

     pthread_detach(pthread_self());
     //找到自己对应的信息
     pthread_rwlock_rdlock(&rw);
     for(i=head.next;i!=&head;i=i->next)
     {
         if(i->sfd==sfd)
         {
             my=i;
             break;
         }
     }
     pthread_rwlock_unlock(&rw);
     printf("\033[36mFrom:%s\033[0m\n",my->ip);

     //消息首部
     snprintf(buf,SIZE,"[%s]:\n  ",my->ip);
     len=strlen(buf);

     while(1)
     {
         ret=recv(sfd,buf+len,SIZE,0);
         if(ret==0||ret==-1)  break;

         pthread_rwlock_rdlock(&rw);
         //转发给所有再线者
         for(i=head.next;i!=&head;i=i->next)
         {
             send(i->sfd,buf,len+ret,0);
         }
         pthread_rwlock_unlock(&rw);
         sched_yield();
         //unlock
     }
     //移除该连接  deleteList(sfd);
     pthread_rwlock_wrlock(&rw);

     printf("\033[31mExit:%s\033[0m\n",my->ip);
     my->next->prev=my->prev;
     my->prev->next=my->next;
     free(my);
     pthread_rwlock_unlock(&rw);
     //
     shutdown(sfd,SHUT_RDWR);

     pthread_exit((void *)0);
}
int initSocket(void)
{
     int sfd,ret;
     struct sockaddr_in   addr;

     sfd=socket(AF_INET,SOCK_STREAM,0);
     if(sfd==-1)
     {
         perror("create socket");
         return -1;
     }

     addr.sin_family=AF_INET;
     addr.sin_port  =htons(SER_PORT);
     addr.sin_addr.s_addr=INADDR_ANY;
     memset(addr.sin_zero,0,8);
     ret=bind(sfd,(struct sockaddr *)&addr,sizeof(addr));
     if(ret==-1)
     {
          perror("bind");
          shutdown(sfd,SHUT_RDWR);
          return -2;
     }
     if(listen(sfd,100)==-1)
     {
          perror("listen");
          shutdown(sfd,SHUT_RDWR);
          return -3;
     }

     return sfd;
}
int appendList(int sfd,char *ip)
{
     struct node *one;
     one=malloc(sizeof(struct  node));
     if(one==NULL)   return -1;

     one->sfd=sfd;
     strcpy(one->ip,ip);

     one->next=&head;
     one->prev=head.prev;
     one->next->prev=one;
     one->prev->next=one;
     return 0;
}
void deleteList(int sfd)
{
     struct node *i;
     for(i=head.next;i!=&head;i=i->next)
     {
         if(i->sfd==sfd)//del
         {
             i->next->prev=i->prev;
             i->prev->next=i->next;
             free(i);
             break;
         }
     }
}

多线程服务器：

因为会涉及到文件描述符使用时的覆盖，所以使用可加入互斥，保证原子操作。


#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <pthread.h>
#include <signal.h>


pthread_mutex_t  mm=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t   ok=PTHREAD_COND_INITIALIZER;
static   int flag=1;

//端口号1--65535  建议用1024之后的
#define       SER_PORT      7777
#define       SER_IP        "192.168.122.1"

#define       MAX_WAIT      10

void *doServer(void *arg)
{
    int ret,i,newsfd;

    pthread_detach(pthread_self());//分离

    //再保护的状态下取newsfd
    pthread_mutex_lock(&mm);
    newsfd=*(int *)arg;
    flag=0;
    pthread_mutex_unlock(&mm);
    pthread_cond_signal(&ok);

    for(i=0;i<10;i++)
    {
        //如果接收放掉线(关闭) 如同写一个没有读端的管道 收到SIGPIPE信号
        ret=write(newsfd,"hello",5);
        if(ret==-1)
        {
            printf("客户端失去连接.\n");
            shutdown(newsfd,SHUT_RDWR);
            pthread_exit((void *)0);
        }
        sleep(1);
    }
    write(newsfd,"bye",3);
    shutdown(newsfd,SHUT_RDWR);
    pthread_exit((void *)0);
}

int main(void)
{
     int sockfd,ret;
     pthread_t   tid;

     //避免当客户端再服务器间意外失去连接,服务线程发送数据时导致触发SIGPIPE 使服务进程死亡
     signal(SIGPIPE,SIG_IGN);

     //0选默认协议
     sockfd=socket(AF_INET,SOCK_STREAM,0);
     if(sockfd==-1)
     {
        perror("create socket");
        return 1;
     }
     //描述主机的结构信息
     struct sockaddr_in  addr;
     addr.sin_family=AF_INET;//指定地址协议
     addr.sin_port  =htons(SER_PORT);//网络字节序(大端字节字节序)
     //addr.sin_addr.s_addr=inet_addr(SER_IP);
     addr.sin_addr.s_addr=INADDR_ANY;//指本机的所有IP(包括127.0.0.1 广播  多播)
     memset(addr.sin_zero,0,8);//填补字节 为匹配之前的结构struct sockaddr
     ret=bind(sockfd,(struct sockaddr *)&addr,sizeof(addr));
     if(ret==-1)
     {
        perror("bind");
        shutdown(sockfd,SHUT_RDWR);
        return 2;
     }
     //监听:MAX_WAIT<半连接队列大小>
     ret=listen(sockfd,MAX_WAIT);
     if(ret==-1)
     {
        perror("bind");
        shutdown(sockfd,SHUT_RDWR);
        return 2;
     }
     printf("Server Start Success,Wait Connect...\n");
     //
     int newsfd;
     struct sockaddr_in   from;
     socklen_t   len=sizeof(from);

     while(1)
     {
        //连接没有到来则阻塞
        //newsfd=accept(sockfd,NULL,NULL);
        newsfd=accept(sockfd,(struct sockaddr *)&from,&len);
        if(newsfd==-1)  continue;//处理失败

        printf("sockfd:%d newsfd:%d from:%s<%d>\n",\
            sockfd,newsfd,inet_ntoa(from.sin_addr),ntohs(from.sin_port));

        //建立进程或线程服务
        ret=pthread_create(&tid,NULL,doServer,&newsfd);
        if(ret!=0)
        {
            write(newsfd,"sorry,can't server",sizeof("sorry,can't server"));
            shutdown(newsfd,SHUT_RDWR);
            continue;
        }

        //等待线程将newsfd取走 避免竞争
        pthread_mutex_lock(&mm);
        while(flag!=0)
        {
           pthread_cond_wait(&ok,&mm);
        }
        flag=1;
        pthread_mutex_unlock(&mm);
     }

     return 0;
}

测试的客户端代码：

client.c

#include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <unistd.h>
  #include <netinet/in.h>
  
  
  #define MAXLINE 80
  #define IP "127.0.0.1"
  #define SERV_PORT 7777
  
  int main(int argc, char* argv[])
  {
      struct sockaddr_in servaddr;
      char buf[MAXLINE];
      int sockfd, n;
      
      sockfd = socket(AF_INET, SOCK_STREAM, 0);
      
      bzero(&servaddr, sizeof(servaddr));
      servaddr.sin_family = AF_INET;
      inet_pton(AF_INET, IP, &servaddr.sin_addr);
      servaddr.sin_port = htons(SERV_PORT);
      
      connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
      
      while(fgets(buf, MAXLINE, stdin) != NULL)
      {
          write(sockfd, buf, strlen(buf));
          n = read(sockfd, buf, MAXLINE);
          if(n == 0)
          {
              printf("the other side has been closed.\n");
          }
          else
          {
              write(STDOUT_FILENO, buf, n);
          }
      }
      close(sockfd);
      return 0;
 
}

 

言xzZ義
关注
专栏目录
并发服务器之多线程和多路复用(select)的区别
linuxwln的博客
08-22 6487
一、I/O复用模型 1、IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合： 　　（1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。 　　（2）当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。 　　（3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复...
I/O 多路复用用协程和用线程的区别？
m0_50654102的博客
05-27 333
线程是执行程序的最小单位。I/O 多路复用时，会用单个线程处理大量的 I/O。还有一种执行程序的模型，叫协作程，协程是轻量级的线程。操作系统将执行资源分配给了线程，然后再调度线程运行。如果要实现协程，就要利用分配给线程的执行资源，在这之上再创建更小的执行单位。协程不归操作系统调度，协程共享线程的执行资源。 而 I/O 多路复用的意义，是减少线程间的切换成本。因此从设计上，只要是用单个线程处理大量 I/O 工作，线程和协程是一样的，并无区别。如果是单线程处理大量 I/O，使用协程也是依托协程对应线程执行能力。
服务器开发中的多进程，多线程及多协程
weixin_33800593的博客
04-20 134
服务器开发中，为了充分利用多核甚至多个cpu，或者是简化逻辑编写的难度，会应用多进程（比如一个进程负责一种逻辑）多线程（将不同的用户分配到不同的进程）或者协程（不同的用户分配不同的协程，在需要时切换到其他协程），并且往往同时利用这些技术比如多进程多线程。 一个经典的服务器框架可以说如下的框架： 而这些服务器进程之间协同配合，为用户提供服务，其中中心服务器提供集群的调度工作，而逻辑服可以是逻...
IO多路复用与进/线程池的优劣对比
快乐星球
04-10 1492
惊群现象 主进程（master 进程）首先通过 socket() 来创建一个 sock 文件描述符用来监听，然后fork生成子进程（workers 进程），子进程将继承父进程的 sockfd（socket 文件描述符），之后子进程 accept() 后将创建已连接描述符（connected descriptor）），然后通过已连接描述符来与客户端通信。 那么，由于所有子进程都继承了父进程的 soc...
Linux&Apue（0.4.0）：多进程和多线程的区别&I/O多路复用的基础知识
NeWorld20的博客
03-24 364
（一）多路复用的基础知识
多路IO_多路IO并发服务器_
10-02
在本案例中，"多路IO并发服务器"指的是使用多路I/O复用来实现一个简易的聊天室服务器。 多路I/O复用主要有三种方式：select、poll和epoll。它们都是系统提供的函数，用于监视多个文件描述符，等待至少一个描述符...
TCP服务器IO模型之多路复用（一）POLL函数.zip
09-20
总的来说，TCP服务器的多路复用IO模型通过POLL函数，有效地解决了高并发场景下服务器性能的问题，提升了服务的响应速度和系统资源利用率。在实际开发中，理解并熟练掌握POLL函数的使用对于构建高效、稳定的网络服务...
多线程Web服务器的设计与实现
11-02
Java语言提供了丰富的多线程API，如`Thread`类和`Runnable`接口，使得创建和管理线程变得简单。 2. **Web服务器工作原理**：一个典型的Web服务器接收到请求后，会解析HTTP报文，根据请求的方法（GET、POST等）来...
多进程&多路复用并发的http服务器
05-23
理解并掌握多进程和多路复用并发的概念对于构建高性能HTTP服务器至关重要。Nginx的成功在于其巧妙地结合了多路复用和事件驱动模型，实现了高效、低延迟的并发处理。通过深入研究和实践，我们可以为自己的HTTP服务器...
网络io与io多路复用select/poll/epoll 服务器并发代码实现
最新发布
08-29
网络I/O多路复用技术则是一种高效处理并发连接的方法，能够提高服务器性能，允许一个进程同时处理多个客户端请求。本文将深入探讨网络I/O的基本概念，以及select、poll和epoll这三种I/O多路复用机制，并通过实际代码...
多进程、多线程服务器
qq_35118894的博客
07-05 889
本篇博客将介绍基于IPv4的socket网络编程。 一、socket1.概念： socket这个词可以表示很多概念：在TCP/IP协议中，“IP地址 + TCP或UDP端口号”唯一标识网络通信中的一个进程，“IP地址 + 端口号”就叫做socket。 在TCP协议中，建立连接的两个进程各自有一个socket来标识，那么这两个socket组成的socket pair就唯一标识一个一个连接，soc
多进程服务器和多线程服务器的实现
每天学习一点点，成长一小步
06-27 997
一、多进程服务器： 1.多进程服务器实现代码：#include <stdlib.h> #include <stdio.h> #include <signal.h>#define P_NUMBER 255 //并发进程数量 #define COUNT 5 //每次进程打印字符串数 #define TEST_LOGFILE "logFile.log" FILE *logFile=NULL;char *
多线程在项目种实际使用的地方
runoob12的博客
11-11 1871
使用多线程的好处: 代码b格更高 充分发挥服务器处理效率，提高系统处理数据 对多线程的理论知识还是了解了一些，但是实际没有多少使用的地方，这次摘抄一些使用多线程的地方，希望以后多多学习，在项目种多多使用； 1.发短信验证码场景： 2.更新操作 3.后台同步信息 4.仅仅只做一个插入操作 总结： 多线程处理一些不阻碍主流程的操作。例如：发短信，发消息。 异步同步数据： 长时间处理数据的操...
简单介绍多进程和多线程游戏服务器
weixin_30855761的博客
01-01 328
首先贴下多进程单线程和单进程多线程的特点： 　　多进程：有独立的地址空间，进程之间不共享内存和变量，但可以通过共享内存实现，每个进程只有一个线程，一般用于单机系统开发。 多线程：在同一个进程下的所有线程可以共享内存和变量。 　 而共同点是，同开辟的进程数/线程数多于系统cpu核数时，无法继续提高应用的性能。 　 而多线程架构的服务器，只要适当将一些任务分出来用新的进程启动，就...
C/C++ 服务器并发
C语言与CPP编程的博客
11-23 959
1. 单线程 / 进程在 TCP 通信过程中，服务器端启动之后可以同时和多个客户端建立连接，并进行网络通信，但是在介绍 TCP 通信流程的时候，提供的服务器代码却不能完成这样的需求，先简单...
Linux进程池、线程池调研
hm108106的博客
06-23 457
1.进程池 （1）进程池是由服务器预先创建的一组子进程，这些子进程的数目在3-10个之间。进程池中的所有子进程都运行着相同的代码，并具有相同的属性，比如优先级，PGID等等。因为进程池在服务器启动之初就创建好了，所以他们没有打开不必要的文件描述符（从父进程继承而来），也不会错误地使用大块的堆内存（从父进程复制得到）。 （2） 当有新的任务到来时，主进程将通过某种方式选择进程池中的某一个
用户态多线程环境下IO端口权限问题
认真做事，乐观做人。
12-30 686
Linux下用户态读写io port需要先使用ioperm或iopl获取io port权限，ioperm和iopl的手册都只是描述了fork 子进程时端口权限继承问题，但是都没有对一个进程中的多个线程间port权限的共享问题作出说明。笔者在多线程环境下读写io port的时候就碰到了一个诡异的问题： 程序有概率地崩溃在outb上，程序内部有一个工作线程池，线程池中的每个线程和进程主线程都可能读写
Q38：游戏服务器为用户开辟线程还是进程？
不积跬步无以至千里
06-26 619
游戏服务器应当为每个用户开辟一个进程。
网络编程实战29 使用epoll和多线程模型
ziggy7的博客
08-24 387
框图 为什么要使用epoll epoll比poll效率高，见三者比较的文章 如何切换到epoll 我们的网络编程框架是可以同时支持 poll 和 epoll 机制的，那么如何开启 epoll 的支持呢？ ib/event_loop.c 文件的 event_loop_init_with_name 函数是关键，可以看到，这里是通过宏 EPOLL_ENABLE 来决定是使用 epoll 还是 poll 的。 struct event_loop *event_loop_init_with_name(char *t
Python并发探索：多进程、多线程、协程与IO多路复用详解
本文档是对Python并发编程中的多进程、多线程、协程和IO多路复用技术进行的系统梳理，适合初学者和进阶者参考。首先，文章强调了网络编程的目标——数据传输，以及ISO国际标准化组织在制定网络通信标准中的角色，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值