Linux网络编程之简单并发服务器

最新推荐文章于 2024-05-09 16:40:23 发布
最新推荐文章于 2024-05-09 16:40:23 发布
阅读量1.9k 收藏 2
点赞数
分类专栏： Linux 网络编程 文章标签： linux 编程 网络 buffer server 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenjin_zhong/article/details/7269649
版权

1.概念

与前面介绍的循环服务器不同，并发服务器对服务请求并发处理。而循环服务器只能够一个一个的处理客户端的请求，显然效率很低. 并发服务器通过建立多个子进程来实现对请求的并发处理，但是由于不清楚请求客户端的数目，因此很难确定子进程的数目。因此可以动态增加子进程与事先分配的子进程相结合的方法来实现并发服务器。

2. 算法流程

(1)TCP简单并发服务器:

    服务器子进程1:

         socket(...);
        bind(...);
        listen(...);
        while(1)
        {
                accept(...);
                recv(....);

                process(...);

                send(.....);

       }
       close(....);//关闭客户端

    服务器子进程2:

         socket(...);
        bind(...);
        listen(...);
        while(1)
        {
                accept(...);
                recv(....);

                process(...);

                send(.....);

       }
       close(....);//关闭客户端

     服务器子进程3

              ...............

              ...............

              ...............

 (2)UDP简单并发服务器

    服务器子进程1:

       socket(...);
        bind(...);
        while(1)
        {
              
                recvfrom(....);

               process(...);

               sendto(.....);

       }

     close(...); //关闭客户端连接

   服务器子进程2,3....与1相同.

这样，同时到达多个请求，就分别由多个进程并发的处理,此算法的的性能取决于请求的数目，如果请求数目越多，这样的子进程就越多，那么进程的切换开销就会很大.而且还不容易确定子进程的数目，所以这是一种简单的并发服务器模型.

3.相关实例

(1)简单并发服务器TCP

服务器:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <time.h>
#include <netinet/in.h>
/**
TCP并发服务器，预先建立进程，同时到来的客户端分别由不同的进程并发处理
**/
#define PORT 8888
#define BUFFERSIZE 1024
#define PIDNUM 2
static void handle(int s){
  int sc;
  struct sockaddr_in client_addr;//客户端地址
  char buffer[BUFFERSIZE];
  int len;
  int ret;
  int size;
  len=sizeof(client_addr);
  time_t now;
//接收客户端的连接
  while(1){
   memset(buffer,0,BUFFERSIZE);
   sc=accept(s,(struct sockaddr*)&client_addr,&len);
   size=recv(sc,buffer,BUFFERSIZE,0);
   if(size>0&&!strncmp(buffer,"TIME",4)){
         memset(buffer,0,BUFFERSIZE);
         now=time(NULL);
         sprintf(buffer,"%24s\r\n",ctime(&now));
         send(sc,buffer,strlen(buffer),0);//发送到客户端
  }
   close(sc);
 }

}

int main(int argc,char*argv[]){
   int s;
   int ret;
   struct sockaddr_in server_addr;
  pid_t pid[PIDNUM];
   int i;
   s=socket(AF_INET,SOCK_STREAM,0);
  if(s<0){
   perror("socket error");
   return -1;
  }
//绑定地址到套接字
  server_addr.sin_family=AF_INET;
  server_addr.sin_port=htons(PORT);
  server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
  ret=bind(s,(struct sockaddr*)&server_addr,sizeof(server_addr));
  if(ret<0){
    perror("bind error");
   return -1;
  }
 ret=listen(s,10);//监听
//建立子进程处理同时到来的客户端请求
 for(i=0;i<PIDNUM;i++){
   pid[i]=fork();
  if(pid[i]==0){
   handle(s);
  }
 }

while(1);
close(s);

}

客户端:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <time.h>
#include <netinet/in.h>
#define PORT 8888
#define BUFFERSIZE 1024
int main(int argc,char*argv[]){
 int s;
 int ret;
 int size;
 struct sockaddr_in server_addr;
 char buffer[BUFFERSIZE];
 s=socket(AF_INET,SOCK_STREAM,0);
 if(s<0){
  perror("socket error");
  return -1;
}
bzero(&server_addr,sizeof(server_addr));
//将地址结构绑定到套接字
server_addr.sin_family=AF_INET;
server_addr.sin_port=htons(PORT);
server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
//连接服务器
 ret=connect(s,(struct sockaddr*)&server_addr,sizeof(server_addr));
 if(ret==-1){
  perror("connect error");
  return -1;
}
memset(buffer,0,BUFFERSIZE);
strcpy(buffer,"TIME");
size=send(s,buffer,strlen(buffer),0);
if(size<0){
  perror("send error");
  return -1;
}
memset(buffer,0,BUFFERSIZE);
size=recv(s,buffer,BUFFERSIZE,0);
if(size<0){
  perror("recv error");
  return;
}

printf("%s",buffer);
close(s);
return 0;
}

运行结果:

[root@localhost 14章服务器模式]# ./circle-tcpc14
Sat Feb 18 10:28:59 2012

(2)UDP简单并发服务器

服务器:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <time.h>
#include <netinet/in.h>
/**
UDP循环服务器处理完一个请求之后才能处理下一个请求，而不能同时处理请求
UDP并发服务器通过事先建立进程，并发的处理来自客户端的请求
缺点：事先建立好子进程，但不知道客户端的数目，难以适应动态变化
**/
//建立2个进程，并发的处理客户端的请求
#define PORT 8888
#define PIDNUM 2
#define BUFFERSIZE 1024
//两个子进程，分别并发的处理客户端的请求
static void handle(int s){
    char buffer[BUFFERSIZE];
    struct sockaddr_in client_addr;
    int len;
    int size;
    len=sizeof(client_addr);
    time_t now;
  while(1){
    memset(buffer,0,BUFFERSIZE);
    size=recvfrom(s,buffer,BUFFERSIZE,0,(struct sockaddr*)&client_addr,&len);
    if(size>0&&!strncmp(buffer,"TIME",4)){
      memset(buffer,0,BUFFERSIZE);
      now=time(NULL);
      sprintf(buffer,"%24s\r\n",ctime(&now));
     size=sendto(s,buffer,strlen(buffer),0,(struct sockaddr*)&client_addr,sizeof(client_addr));
     if(size<=0){
     perror("sendto error");
    }
    }   
}

}

int main(int argc,char*argv[]){
 int s;//套接字描述符
 int ret;//返回值
 int size;
 
 int i;
 pid_t pid[PIDNUM];
 struct sockaddr_in server_addr;
//建立套接字
 s=socket(AF_INET,SOCK_DGRAM,0);
 if(s<0){
   perror("socket error");
   return -1;
 }
 bzero(&server_addr,sizeof(server_addr));
 server_addr.sin_family=AF_INET;
 server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
 server_addr.sin_port=htons(PORT);
//将地址结构绑定到套接字描述符
 ret=bind(s,(struct sockaddr*)&server_addr,sizeof(server_addr));
 if(ret==-1){
   perror("bind error");
   return -1;
 }
//接收数据并处理,主函数建立两个进程，让进程并发的处理请求
 for(i=0;i<PIDNUM;i++){
   pid[i]=fork();
  if(pid[i]==0){
    handle(s);//让子进程去处理
}
}

while(1);//父进程等待
return 0;
}

客户端:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <time.h>
#include <netinet/in.h>
/**
UDP端，客户端向服务器发送时间请求，服务器返回相应的时间
**/
#define PORT 8888
#define BUFFERSIZE 1024
int main(int argc,char*argv[]){
  int s;//套接字描述符
  int ret;//建立套接字的返回值
  int size;
  struct sockaddr_in server_addr;//地址结构
  int len;
  char buffer[BUFFERSIZE];
  s=socket(AF_INET,SOCK_DGRAM,0);//建立流式套接字
  if(s<0){
    perror("socket error");
    return -1;
  }
 bzero(&server_addr,sizeof(server_addr));
  server_addr.sin_family=AF_INET;
  server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
  server_addr.sin_port=htons(PORT);
  memset(buffer,0,BUFFERSIZE);
  strcpy(buffer,"TIME");
 //向服务器发送数据
 size=sendto(s,buffer,strlen(buffer),0,(struct sockaddr*)&server_addr,sizeof(server_addr));
 if(size<0){
   perror("sendto error");
   return -1;
 }
 //从服务器接收数据
 len=sizeof(server_addr);
  size=recvfrom(s,buffer,BUFFERSIZE,0,(struct sockaddr*)&server_addr,&len);
 if(size<0){
   perror("recvfrom error");
  return -1;
 }
  //write(1,buffer,size);
  printf("%s\n",buffer);
 close(s);
 return 0;
}


总结:本文主要介绍了简单的TCP与UDP并发服务器，并给出了实例.这种简单的并发服务器很难适应动态变化的客户端请求，所以，接下来将介绍高级并发服务器.


chenjin_zhong
关注
专栏目录
linux网络编程之并发服务器的三种实现模型 （超级经典）
码莎拉蒂
03-12 5877
转载 ： http://blog.csdn.net/tennysonsky/article/details/45671215 服务器设计技术有很多，按使用的协议来分有 TCP 服务器和 UDP 服务器，按处理方式来分有循环服务器和并发服务器。 循环服务器与并发服务器模型 在网络程序里面，一般来说都是许多客户对应一个服务器（多对一），为了处理客户的请求，对服务端的程序就提出
【Linux网络编程】高并发服务器 socket+epoll封装 服务器/客户端举例
持续学习，持续进步！
06-29 3937
本文主要介绍高并发服务器设计，socke+epoll封装，以及相关代码示例说明
什么样的服务器才能叫做大并发
xiaofei chain
03-13 4943
我觉得服务器在成为大并发前，首先要能承受住大并发的压力，无论能否正常返回，首先不能崩溃。 apache和nginx是两个出名的服务器，先来分析一下它们。 大量用户访问的时候，apache会创建大量的进程数，吃掉大量的内存，而nginx内存这块做得很好，不过这也是nginx的瓶颈所在。 所谓有内存就是给你花的，你不花怎么对得起服务器呢，何况现在的服务器一般都是高配。 快速响应与内存大小其实是
Linux网络编程(高并发服务器)
m0_49476241的博客
08-17 1193
本篇文章带大家学习Linux网络编程中的高并发服务器。首先我们需要了解什么是高并发服务器，然后是学习如何来编写高并发服务器。高并发服务器是指能够同时处理大量并发请求的服务器系统。在网络应用中，当多个用户或客户端同时请求服务器时，服务器需要能够高效地处理这些请求，并且保持良好的性能和稳定性。1.多线程或多进程处理：采用多线程或多进程的方式可以使服务器能够同时处理多个请求。每个线程或进程负责处理一个请求，从而提高服务器的并发处理能力。
linux网络编程-多线程实现TCP并发服务器
天道酬勤
02-27 1022
1. socket函数创建监听套接字lfd; 2. bind函数将监听套接字绑定ip和端口； 3. listen函数将服务器设置为被动监听状态，同时创建一条未完成连接队列（没走完tcp三次握手流程的连接），和一条已完成连接队列（已完成tcp三次握手的连接）； 4. accept函数循环的从已完成连接的队列中提取连接，并返回一个新的套接字cfd跟客户端进行通信； 5. pthread_create函数创建一个子线程，跟客户端进行通信； 6. 子线程：read函数循环的从r缓冲区读取客户端发送的数据。。。
Linux网络编程:TCP并发服务器实现
最新发布
weixin_42937740的博客
05-09 1109
本文通过多进程和多线程技术进行的TCP并发服务器的实现，在多进程方式下，解决了僵尸进程的问题。最后通过完成代码的编写并测试，成功实现了TCP并发服务器。
linux网络编程 -- 并发服务器
m0_60292931的博客
07-14 496
无
Linux网络编程---UDP服务器
qq_51647149的博客
04-29 2506
UDP通信与TCP通信的对比及实现、网络/本地套接字通信的对比
linux网络编程-多进程实现TCP并发服务器
天道酬勤
02-23 2457
• socket函数创建监听套接字lfd • bind函数将监听套接字绑定ip和端口 • listen函数设置服务器为被动监听状态，同时创建一条未完成连接队列（没走完tcp三次握手流程的连接），和一条已完成连接队列（已完成tcp三次握手的连接） • accept函数循环的从已完成连接队列中提取连接，并返回一个新的套接字cfd跟客户端进行通信 • fork函数创建一个子进程，让子进程与客户端进行通信 • 子进程：read函数循环的从r缓冲区读取客户端发送的数据，write函数将要发送的数据写入w缓冲区
Linux网络编程-网络基础-socket编程-高并发服务器.pdf
09-05
【Linux网络编程-网络基础-socket编程-高并发服务器】 在深入探讨Linux下的网络编程之前，我们首先要理解网络通信的基础概念——协议。协议是数据传输和解释的规则，它确保了不同设备之间的通信能顺利进行。例如，...
黑马_Linux网络编程-网络基础-socket编程-高并发服务器
02-16
### 黑马_Linux网络编程-网络基础-socket编程-高并发服务器 #### 知识点概述 本篇文章旨在深入解读“黑马_Linux网络编程-网络基础-socket编程-高并发服务器”相关的核心概念和技术要点，包括网络基础知识、常用...
01_Linux网络编程-网络基础-socket编程-高并发服务器1
08-03
在Linux系统中，进行网络编程时通常会使用Socket API，它是跨平台的网络通信接口。通过创建Socket，应用程序可以建立到其他系统的连接，实现数据的收发。Socket编程涉及到网络套接字的创建、绑定、监听、连接和数据...
Linux 网络编程之ioctl函数
02-18 7868
1.介绍 Linux网络程序与内核交互的方法是通过ioctl来实现的，ioctl与网络协议栈进行交互，可得到网络接口的信息，网卡设备的映射属性和配置网络接口.并且还能够查看，修改，删除ARP高速缓存的信息，所以，我们有必要了解一下ioctl函数的具体实现. 2.相关结构体与相关函数 #include int ioctl(int d,int request,....); 参数: d
Linux 网络编程之UDP
02-14 3632
1.介绍 UDP协议是无连接的，不可靠传输的协议. 服务器与客户端的交互不需要建立连接，没有流量控制的功能。与TCP一样，它也是传输层协议，通信过程中需要IP地址与端口号。使用UDP进行程序设计包括服务器与客户端，下面介绍一下服务器与客户端的通信流程: 服务器流程: (1)建立服务器套接字描socket (2)将地址结构绑定到套接字上 bind (3)数据传输 sendto/recvfr
Linux网络编程之套接字选项设置
02-17 3590
1.介绍 在Linux网络编程中，有时需要设置地址复用，允许发送广播包，将主机加入某个多播组，设置发送与接收缓冲区的大小，设置发送与接收的超时时间，将套接字绑定到某个接口上,发送TCP探测包查看客户端是否保持连接等，这些都需要对套接字选项进行设置.而对套接字选项进行操作的主要有以下两个函数,setsockopt与getsockopt. 这两个函数不仅能够操作套接字层，而且能够操作IP层与TCP层
Linux网络编程之广播
02-18 3529
1.概念 前面介绍的TCP,UDP都是单播方式，即一对一.而广播是一台主机向局域网内的所有主机发送数据。这时，同一网段的所有主机都能接收到数据。发送广播包的步骤大致如下: (1)确定一个发送广播的接口，如eth0 (2)确定广播的地址，通过ioctl函数，请求码设置为SIOCGIFBRDADDR得到广播的地址 (3)使用这个广播地址进行广播 由于TCP协议是端到端的协议，在通信之前，必须
Linux网络编程之多播
02-18 3509
1.概念 单播是用于两个主机之间传送数据，广播是一个主机对局域网内的所有主机发送数据。而多播，又称为组播，它是对一组特定的主机通信。将网络上同一类型业务逻辑上分组，只和组内的成员通信，其它主机没有加入组则不能通信。与单播相同的是，组播允许在Internet上通信，而广播只是同一局域网内的主机通信。组播地址是特定的，D类地址用于组播，即244.0.0.0到239.255.255.255. 并划分为
Linux网络编程之高级并发服务器
02-18 3310
1. 介绍 在上一节，我们介绍了Linux简单的并发服务器，通过在服务器端建立多个子进程，来接收客户端的请求，实现并发处理，但这种方式明显有缺陷,服务器并不知道客户端请求的数量，所以事先建立的进程数不好确定。所以，这里介绍三种高级并发服务器模式。第一种是服务器端统一accept,接收客户端的到来，然后为每个客户端分配一个进程去处理. 第二种是统一accept接收请求，然后为每个客户端分配一个线程
Linux网络编程详解：从基础到高并发服务器实现
压缩包子文件的文件名称列表中的文件名 "01_Linux网络编程-网络基础-socket编程-高并发服务器.docx" 表明了文档的内容结构，它按照顺序排列了学习Linux网络编程的主题，从基础到高并发服务器的进阶知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值