Linux网络编程之高级并发服务器

最新推荐文章于 2023-05-30 20:01:32 发布
最新推荐文章于 2023-05-30 20:01:32 发布
阅读量654 收藏
点赞数
分类专栏： 网络编程 文章标签： 网络编程 并发 服务器
本文介绍了三种高级并发服务器模式：统一accept多进程、统一accept多线程及多线程独立accept。并通过具体示例展示了每种模式下服务器端的实现方式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

原文：http://blog.youkuaiyun.com/chenjin_zhong/article/details/7269717    点击打开链接

1. 介绍

在上一节，我们介绍了Linux简单的并发服务器，通过在服务器端建立多个子进程，来接收客户端的请求，实现并发处理，但这种方式明显有缺陷,服务器并不知道客户端请求的数量，所以事先建立的进程数不好确定。所以，这里介绍三种高级并发服务器模式。第一种是服务器端统一accept,接收客户端的到来，然后为每个客户端分配一个进程去处理. 第二种是统一accept接收请求，然后为每个客户端分配一个线程去处理。第三种建立多个线程去处理客户端请求，每个线程独自监听客户端的请求。显然，第一种方案解决了简单服务器的并发问题。第二种方案其实是对第一种方案的改进，因为线程切换的开销明显要小于进程切换的开销。第三种方案就是原来用进程去处理每个请求，现在换成用线程去处理，个人认为改进不是很大.

2. 高级并发服务器算法流程

(1) 统一accept,多进程

  socket(...);
  bind(...);
  listen(...);
  while(1){
    accept(...);
    fork(...);//子进程
  }
  close(...);//关闭服务器套接字

子进程：

 recv(...);
 process(...);
 send(...);
 close(...);//关闭客户端

(2) 统一accept,多线程

  socket(...);
  bind(...);
  listen(...);
  while(1){
    accept(...);
    pthread_create(....);  
  }
  close(...);//关闭服务器

线程1：

recv(....);
process(....);
send(...);
close(...);//关闭客户端

(3) accept放入每个线程

 socket(...);
 bind(...);
 listen(...);
 pthread_create(...);
 pthread_join(...);//等待线程结束
 close(...);//关闭服务器

线程1：

Mutex_lock//互斥锁
accept(...);
Mutex_unlock(...);
recv(...);
process(...);
send(...);
close(...);//客户端

3. 相关例子（TCP服务器）

(1) 统一accept多进程

服务器：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <time.h>
/**
 高级并发服务器
 TCP统一accept
 当有客户端到来时,为每个客户端建立进程，然后每个进程处理客户端的请求，动态的建立进程
**/
#define PORT 8888
#define BUFFERSIZE 1024
#define BACKLOG 2

static void handle(int sc){//处理客户端的请求
  char buffer[BUFFERSIZE];
  time_t now;
  int size;
  memset(buffer,0,BUFFERSIZE);
  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 ret;
  int s;
  int sc;//用于服务器与客户端进行数据传输的套接字
  struct sockaddr_in server_addr;
  struct sockaddr_in client_addr;
  int len;
  len=sizeof(client_addr);
  //建立流式套接字
  s=socket(AF_INET,SOCK_STREAM,0);
  if(s<0){
    perror("socket error");
    return -1;
  }
  //将地址结构绑定到套接字描述符上去
  memset(&server_addr,0,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=bind(s,(struct sockaddr*)&server_addr,sizeof(server_addr));
  if(ret==-1){
    perror("bind error");
    return -1;
  }
  ret=listen(s,BACKLOG);
  if(ret<0){
    perror("listen error");
    return -1;
  }

  while(1){
    sc=accept(s,(struct sockaddr*)&client_addr,&len);
    if(sc<0){
      continue;
    }
    if(fork()==0){//子进程
      handle(sc);
      close(s);//子进程关闭用于监听的套接字
    }else{
      close(sc);//父进程关闭客户端套接字
    }
  }
}
客户端： 

#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;
}

(2) 统一accept多线程

服务器：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <time.h>
/**
  TCP并发服务器，采用多线程，每次客户端发送请求，主线程建立一个子线程，用于处理客户端的请求
  线程具有速度快，占用资源少，数据可以共享等优点 统一accept
**/
#define PORT 8888
#define BUFFERSIZE 1024
#define BACKLOG 2

static void handle(void* sc1){
  int sc;
  time_t now;
  char buffer[BUFFERSIZE]; 
  int size;
  sc=*((int*)sc1);//转换成int指针，然后取值,sc1本身就是一个指针
  memset(buffer,0,BUFFERSIZE);
  size=recv(sc,buffer,BUFFERSIZE,0);
  if(size>0&&!strncmp(buffer,"TIME",4)){//请求服务器的时间 
     memset(buffer,0,BUFFERSIZE);//清0
     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 ret;
  int s;
  int sc;
  int len;
  pthread_t thread1;//定义线程名
  struct sockaddr_in server_addr,client_addr;
  len=sizeof(client_addr);
  //建立流式套接字
  s=socket(AF_INET,SOCK_STREAM,0);
  if(s<0){
    perror("socket error");
    return -1;
  }
  //将服务器端的地址结构绑定到套接字描述符
  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(struct sockaddr_in));
  if(ret<0){
    perror("bind error");
    return -1;
  }
  //监听
  ret=listen(s,BACKLOG);
  if(ret<0){
    perror("listen error");
    return -1;
  }

  //接收客户端的请求
  for(;;){
    sc=accept(s,(struct sockaddr*)&client_addr,&len);
    if(sc<0){
      continue;
    } else {
      pthread_create(&thread1,NULL,handle,(void*)&sc);//建立线程，让线程去处理,最后一个字段是传递给线程处理函数handle的参数
    }
  }

  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;
}

(3) 单独线程accept

服务器：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <time.h>
#include <pthread.h>
/**
  多线程TCP并发服务器
  主线程创建多个线程，然后每个线程独立的accept和进行数据的发送与接收
  多线程，独立accept
**/
#define PORT 8888
#define BUFFERSIZE 1024
#define BACKLOG 2
#define CLIENTNUM 3
static void *handle(void* s1){
  int s;
  int len;
  int sc;
  pthread_mutex_t alock=PTHREAD_MUTEX_INITIALIZER;
  char buffer[BUFFERSIZE];
  int size;
  struct sockaddr_in client_addr;
  s=*((int*)s1);//得到服务器端的套接字描述符
  //等待客户端连接
  len=sizeof(client_addr);
  for(;;){//不停的循环等待客户端的连接
    time_t now;
    //进入互斥区,每次一个线程处理客户端
    pthread_mutex_lock(&alock); 
    sc=accept(s,(struct sockaddr*)&client_addr,&len);
    pthread_mutex_unlock(&alock);
    memset(buffer,0,BUFFERSIZE);
    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 ret;
   int s;
   int len;
   int i;
   pthread_t thread[CLIENTNUM];
   struct sockaddr_in server_addr;
   //建立流式套接字
   s=socket(AF_INET,SOCK_STREAM,0);
   if(s<0){
      perror("socket error");
      return -1;
   }
   //将地址结构绑定到套接字上
   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(struct sockaddr_in));
   if(ret==-1){
      perror("bind error");
      return -1;
   }
   //监听
   ret=listen(s,BACKLOG);
   if(ret==-1){
      perror("listen error");
      return -1;
   }

   //建立3个线程，每个线程独立的accept
   for(i=0;i<CLIENTNUM;i++){
      pthread_create(&thread[i],NULL,handle,(void*)&s);//线程的处理函数为handle,传递的参数为套接字描述符s    
   }
   //while(1);
   //等待线程结束
   for(i=0;i<CLIENTNUM;i++){
     pthread_join(thread[i],NULL);
   }
   //关闭套接字
   close(s);

   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>
#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;
}


总结：

统一accept,多进程服务器是对简单并发服务器的改进，而由于进程的切换开销比较大，所以又有了统一accept，多线程的并发服务器。而单独线程的accept是完全用线程来处理请求。这些都是TCP服务器，由于UDP是突发的数据流，没有三次握手，所以服务器不能检测到客户端什么时候发送数据。以上三种高级并发服务器仍然存在着性能问题，下一节介绍的I/O复用的循环服务器是对这三种高级并发服务器的改进。


linux网络编程之并发服务器的三种实现模型 （超级经典）
码莎拉蒂
03-12 5939
转载 ： http://blog.youkuaiyun.com/tennysonsky/article/details/45671215 服务器设计技术有很多，按使用的协议来分有 TCP 服务器和 UDP 服务器，按处理方式来分有循环服务器和并发服务器。 循环服务器与并发服务器模型 在网络程序里面，一般来说都是许多客户对应一个服务器（多对一），为了处理客户的请求，对服务端的程序就提出
Linux网络编程-网络基础-socket编程-高并发服务器
04-11
Linux网络编程-网络基础-socket编程-高并发服务器，非常详细的资料，值得你学习。
linux网络编程----->高并发--->多线程并发服务器
weixin_34301307的博客
06-20 147
做网络服务的时候并发服务端程序的编写必不可少。前端客户端应用程序是否稳定一部分取决于客户端自身，而更多的取决于服务器是否相应时间够迅速，够稳定．常见的linux并发服务器模型；多进程并发服务器多线程并发服务器select多路I/O转接服务器poll多路I/O转接服务器epool多路I/O转接服务器．本次主要讨论多线程并发服务器模型：...
linux 网络编程（3） --- 高并发服务器
ghost_him的博客
07-10 889
高并发服务器编程
linux网络编程：高并发服务器模型(三) poll
Jags的博客
05-27 194
一、概述
Linux 网络编程与高并发服务器设计
最新发布
07-14
内容概要：本文档全面介绍了Linux网络编程中的Socket编程，涵盖从基础理论到高级应用的各个方面。首先阐述了网络基础概念，如协议、分层模型（OSI七层模型和TCP/IP四层模型），并详细解析了TCP和UDP这两种传输层协议...
Linux网络编程-socket编程详解与高并发服务器设计
06-22
内容概要：本文详细介绍了Linux网络编程的基础知识，涵盖网络协议（如TCP、UDP）、网络应用程序设计模式（C/S和B/S模式）、分层模型（OSI七层模型和TCP/IP四层模型）、网络通信过程、套接字编程、高并发服务器实现...
Linux网络编程-网络基础-socket编程-高并发服务器.pdf
09-05
【Linux网络编程-网络基础-socket编程-高并发服务器】 在深入探讨Linux下的网络编程之前，我们首先要理解网络通信的基础概念——协议。协议是数据传输和解释的规则，它确保了不同设备之间的通信能顺利进行。例如，...
【Linux网络编程】高并发服务器 socket+epoll封装 服务器/客户端举例
持续学习，持续进步！
06-29 4104
本文主要介绍高并发服务器设计，socke+epoll封装，以及相关代码示例说明
黑马_Linux网络编程-网络基础-socket编程-高并发服务器
02-16
综上所述，“黑马_Linux网络编程-网络基础-socket编程-高并发服务器”涵盖的内容非常丰富，从基本的网络概念到高级的应用程序设计模式均有涉及。理解这些核心概念和技术对于开发高效、可靠的网络应用程序至关重要。...
linux高并发网络编程开发(tcp三次握手-并发)11_socket函数封装，tcp三次握手，tcp的数据传输过程，四次挥手，滑动窗口，tcp多进程并发服务器，多线程并发服务器实现
weixin_41865866的博客
05-30 239
socket函数封装，tcp三次握手，tcp的数据传输过程，四次挥手，滑动窗口，tcp多进程并发服务器，多线程并发服务器实现
Linux高并发服务器开发—网络编程（一）
梅山
07-07 675
网卡是一块被设计用来允许计算机在计算机网络上进行通讯的计算机硬件，又称为网络适配器或网 络接口卡NIC。其拥有 地址，属于 OSI 模型的第 层，它使得用户可以通过电缆或无线相互 连接。每一个网卡都有一个被称为 MAC 地址的独一无二的 位串行号。 网卡的主要功能1.数据的封装与解封装2.链路管理3.数据编码与译码MAC 地址（Media Access Control Address），直译为媒体存取控制位址，也称为局域网地址、以太网地址、物理地址或硬件地址，它是一个用来的位址，由网络设备制造商生产时
[Linux网络编程] 并发服务器的实现
我的博客
11-15 517
一、并发服务器 并发服务器模型的实现主要有三种方式： 1. 多进程 2. 多线程 3. 调用fcntl将sockfd设置为非阻塞模式 二、多进程方式（参考代码C语言） /***************************************************** File name：并发服务器 Author：Zhengqijun Version:1.2 Dat
深入探索 Linux listen() 函数 backlog 的含义
热门推荐
杨博东的博客
03-05 2万+
1：listen()回顾以及问题引入 2：正确的解释 3：实验验证 1：listen()回顾以及问题引入listen()函数是网络编程中用来使服务器端开始监听端口的系统调用，首先来回顾下listen()函数的定义： 有关于第二个参数含义的问题网上有好几种说法，我总结了下主要有这么3种： Kernel会为LISTEN状态的socket维护一个队列，其中存放SYN RECEIVED和EST
数据压缩通讯实现
站在树顶端设计的男人
04-12 330
在传输文件或者其他的网络数据时，I/O经常是高并发的瓶颈，如果一台服务器的带宽只有1M，那么每秒理论上的最大传输速率只有128kb/s，这将极大的限制了并发数量，此时，只能在I/O上进行压缩，将大块数据经过压缩算法转换为某种二进制，然后进行传输，再到服务端通过解压算法进行解压缩，进行业务逻辑处理。
linux多播技术
L_yangliu的专栏
12-20 1万+
CU首页 >> 读书频道 >> 分类浏览 >> Linux网络编程 >> 阅读内容 Linux网络编程 11.3 多 播 单播用于两个主机之间的端对端通信，广播用于一个主机对整个局域网上所有主机上的数据通信。单播和广播是两个极端，要么对一个主机进行通信，要么对整个局域网上的主机进行通信。实际情况下，经常需要对一组特定的主机进行通
【Linux网络编程】高并发服务器编程 -- 进程池与线程池
CopperSun 技术博客
08-16 966
【Linux网络编程】高并发服务器编程-- 进程池与线程池 【1】动态创建进程/线程实现高并发的缺点 耗费时间，响应慢； 动态创建的子进程/子线程通常只能为一个客户服务，将导致系统产生大量的细微进程/线程，进程/线程切换将会耗费大量CPU时间； 当前进程必须合理管理其分配的各项资源，否则有可能导致可用资源衰竭； 【2】进程池与线程池概述 进程池/线程池由系统预先创建一组进程（数目在3-...
Linux网络编程 使用epoll实现一个高性能TCP Echo服务器
chengjuelai7601的博客
07-06 539
#零、前言 在Linux网络编程中，使用I/O复用来处理大规模并发连接是一种常见的方法，常用的有select、poll、epoll，本文主要讲述epoll的使用方法，并使用epoll实现一个高性能的Echo服务器，即把收到的数据原样返回给客户端。最后分析与select和poll的区别，并介绍一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值