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

最新推荐文章于 2023-05-30 20:01:32 发布
最新推荐文章于 2023-05-30 20:01:32 发布
阅读量264 收藏 1
点赞数
分类专栏： linux 服务器 文章标签： linux 网络编程 服务器

转自http://www.360doc.com/userhome.aspx?userid=7534118&cid=35

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复用的循环服务器是对这三种高级并发服务器的改进。

黎明前的沉睡forever
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马_Linux网络编程-网络基础-socket编程-高并发服务器
02-16
黑马程序员linux服务器开发网络编程配套文档，很好的参考资料
操作系统socket通信实验
weixin_59421525的博客
03-23 545
实现UNIX系统下socket通信
linux高并发网络编程开发(tcp三次握手-并发)11_socket函数封装，tcp三次握手，tcp的数据传输过程，四次挥手，滑动窗口，tcp多进程并发服务器，多线程并发服务器实现
weixin_41865866的博客
05-30 67
socket函数封装，tcp三次握手，tcp的数据传输过程，四次挥手，滑动窗口，tcp多进程并发服务器，多线程并发服务器实现
【Linux网络编程】高并发服务器 socket+epoll封装 服务器/客户端举例
持续学习，持续进步！
06-29 3650
本文主要介绍高并发服务器设计，socke+epoll封装，以及相关代码示例说明
Linux高并发服务器开发—网络编程（一）
梅山
07-07 589
网卡是一块被设计用来允许计算机在计算机网络上进行通讯的计算机硬件，又称为网络适配器或网 络接口卡NIC。其拥有 地址，属于 OSI 模型的第 层，它使得用户可以通过电缆或无线相互 连接。每一个网卡都有一个被称为 MAC 地址的独一无二的 位串行号。 网卡的主要功能1.数据的封装与解封装2.链路管理3.数据编码与译码MAC 地址（Media Access Control Address），直译为媒体存取控制位址，也称为局域网地址、以太网地址、物理地址或硬件地址，它是一个用来的位址，由网络设备制造商生产时
Linux网络编程-网络基础-socket编程-高并发服务器.pdf
09-05
《Linux下C语言socket网络编程视频教程》对应文档 https://www.bilibili.com/video/BV1J4411j7Rx?p=19&spm_id_from=pageDriver
Linux网络编程-网络基础-socket编程-高并发服务器
04-11
Linux网络编程-网络基础-socket编程-高并发服务器，非常详细的资料，值得你学习。
01_Linux网络编程-网络基础-socket编程-高并发服务器1
08-03
1. 物理层：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等 2. 数据链路层：定义了如何让格式化数据以帧为单位进行传输，以及
Linux网络编程之IO复用循环服务器
08-26
而并发服务器可以通过创建多个进程或者是线程来并发的处理多个请求。但由于进程或线程的切换会带来一定的开销。而且随着客户端请求的增多,创建的线程或进程的数目也越来越多，开销势必会增加。因此，本文提出了I/O...
数据压缩通讯实现
站在树顶端设计的男人
04-12 224
在传输文件或者其他的网络数据时，I/O经常是高并发的瓶颈，如果一台服务器的带宽只有1M，那么每秒理论上的最大传输速率只有128kb/s，这将极大的限制了并发数量，此时，只能在I/O上进行压缩，将大块数据经过压缩算法转换为某种二进制，然后进行传输，再到服务端通过解压算法进行解压缩，进行业务逻辑处理。
linux网络编程之-----多播（组播）编程
热门推荐
博学而笃志，切问而近思
12-22 2万+
什么是多播        单播用于两个主机之间的端对端通信，广播用于一个主机对整个局域网上所有主机上的数据通信。单播和广播是两个极端，要么对一个主机进行通信，要么对整个局域网上的主机进行通信。实际情况下，经常需要对一组特定的主机进行通信，而不是整个局域网上的所有主机，这就是多播的用途。    多播，也称为“组播”，将局域网中同一业务类型主机进行了逻辑上的分组，进行数据收发的
宏定义错误导致编译出错——期待括号
huqinwei的专栏
06-20 6280
网上复制的组播代码，略有问题，无头文件，服务端宏定义处发现多了个“;”——顺手删了，没关心宏定义，主要是添加头文件，编译成功。 当时以为只是画蛇添足，删不删就是个习惯，对结果影响不大，没想到会是错误源头。     到了客户端，出现了编译错误。   expected ‘)’ before ‘;’ token   编译不通过，以为是圆角和字符编码的问题，因为代码是直接复制进虚拟机的
网络编程（socket）: 基于tcp的服务端与客户端聊天小程序
afvf27467的博客
04-09 414
一、基础概念 1、网络架构 Client/Server结构(C/S结构)客户机和服务器结构。本文的主角。B/S结构（Browser/Server，浏览器/服务器模式），WEB浏览器是客户端最主要的应用软件。 2、IP IP地址是网路通信寻址的主要手段 3、端口（port ） 每台计算机有很多个端口。通常是一个进程（运行着的程序）对应一个端口，访问该主机的某个端口就是访问对应的...
Linux网络编程——tcp并发服务器（多线程）
每天积累一点点
06-15 2万+
tcp多线程并发服务器 多线程服务器是对多进程服务器的改进，由于多进程服务器在创建进程时要消耗较大的系统资源，所以用线程来取代进程，这样服务处理程序可以较快的创建。据统计，创建线程与创建进程要快 10100 倍，所以又把线程称为“轻量级”进程。线程与进程不同的是：一个进程内的所有线程共享相同的全局内存、全局变量等信息，这种机制又带来了同步问题。 tcp多线程并发服务
tcp_client_send_bind8888.c
autumn20080101的专栏
10-03 1272
#include #include #include #include #include #include #include #include #define portnumber 3333 #define MyTCPportnumber 8888 int main(int argc, char *argv[]) { int sockfd; char
Linux网络编程——简单基于TCP协议的服务器/客户端示例
weixin_42645653的博客
11-11 4486
说明：   本文章旨在总结备份、方便以后查询，由于是个人总结，如有不对，欢迎指正；另外，内容大部分来自网络、书籍、和各类手册，如若侵权请告知，马上删帖致歉。   QQ 群 号：513683159 【相互学习】 内容来源：   《Linux网络编程》 功能描述：   客户端连接服务器后从标准输入读取字符串发送给服务器。   服务器接收到字符串后，发送接收到的总字符串个数给客户端、   客户端将接受到的服务器信息打印到标准输出。   整个过程流程如下： 源文件 服务器端源文件：tcp_server.c /**
linux多播技术
L_yangliu的专栏
12-20 9904
CU首页 >> 读书频道 >> 分类浏览 >> Linux网络编程 >> 阅读内容 Linux网络编程 11.3 多 播 单播用于两个主机之间的端对端通信，广播用于一个主机对整个局域网上所有主机上的数据通信。单播和广播是两个极端，要么对一个主机进行通信，要么对整个局域网上的主机进行通信。实际情况下，经常需要对一组特定的主机进行通
深入探索 Linux listen() 函数 backlog 的含义
杨博东的博客
03-05 2万+
1：listen()回顾以及问题引入 2：正确的解释 3：实验验证 1：listen()回顾以及问题引入listen()函数是网络编程中用来使服务器端开始监听端口的系统调用，首先来回顾下listen()函数的定义： 有关于第二个参数含义的问题网上有好几种说法，我总结了下主要有这么3种： Kernel会为LISTEN状态的socket维护一个队列，其中存放SYN RECEIVED和EST
linux网络编程 pdf
最新发布
09-29
通过实际的示例代码和案例分析，读者可以学习如何在Linux操作系统下开发各种网络应用程序，如网络客户端、服务器程序、多线程网络编程、并发编程等。 此书适合有一定Linux操作系统基础和编程经验的读者。对于想要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值