Linux網絡編程之簡單併發服務器

原創 chenjin_zhong 2020-02-25 00:09

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併發服務器，並給出了實例.這種簡單的併發服務器很難適應動態變化的客戶端請求，所以，接下來將介紹高級併發服務器.


發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

linux網絡編程之socket（七）：一個進程發起多個連接和gethostbyname等函數

一、在前面講過的最簡單的回射客戶/服務器程序中，一個客戶端即一個進程，只會發起一個連接，只要稍微修改一下就可以讓一個客戶端發起多個連 接，然後只利用其中一個連接發送數據。 先來認識一個函數getsockname   #inc

weixin_40093087 2020-07-07 06:14:40

TCP的四次揮手爲什麼需要2MSL ？

衆所周知，TCP建立連接三次握手，斷開連接四次揮手，具體流程如下：   MSL是什麼意思？ MSL,  the maximum segment lifetime （最長報文段壽命） 。 segment可以在網絡中存活的最長時間，超過這個

程序员攻略 2020-06-24 23:35:11

Linux多人羣聊系統（簡單多線程服務器）

文章目錄一、要求二、提示1. 服務器端2. 客戶端三、程序四、測試     一、要求 通過一個服務器實現最多5個客戶之間的信息羣發。 服務器顯示客戶的登錄與退出； 客戶連接後首先發送客戶名稱，之後發送羣聊信息； 客戶輸入bye代

Grace、 2020-06-18 22:09:23

Linux進程間通信_IPC機制

剛開始接觸IPC機制時，感覺這個知識點真的時晦澀難懂，因此自己將自己對IPC機制的理解做下總結。 Linux中的IPC機制：信號量， 共享內存， 消息隊列。 注意這裏的IPC機制的通信只能在一臺主機上的多個進程線程之間進行通信，而跨主機之

xixihaha331 2020-06-16 11:55:05

socket、 send、recv、阻塞相關

一、recv和recvfrom的區別 原文鏈接： http://blog.csdn.net/jiangzhuzhu/article/details/5686517 2015.3.02   2015.8.18 2010-06-22

atefrice 2020-06-16 05:48:17

Linux 網絡編程——內網和外網之間的通信流程

對於初學者而已，我們學習的網絡編程（如TCP,UDP編程），我們通常都是在局域網內進行通信測試，有時候我們或者會想，我們現在寫的內網網絡數據和外網的網絡數據有什麼不同，我們內網的數據是如何走出外網的呢？ 再者，我們大多人都是使用寬帶上網，

Hamlee67 2020-06-07 09:42:22

Linux 網絡編程——IP 分片丟失重傳

儘管 IP 分片看起來是是透明的，但有一點讓人不想使用它：即使只丟失一片數據也要重傳整個數據報。爲什麼會發生這種情況呢？ 因爲 IP 層本身沒有超時重傳的機制——由更高層來負責超時和重傳（ TCP 有超時和重傳機制，但 UDP 沒有。一些

Hamlee67 2020-06-07 09:42:12

Linux網絡編程之IPv6

chenjin_zhong 2020-06-02 06:03:30

Linux 網絡編程之UDP

chenjin_zhong 2020-02-25 00:09:31

Linux網絡編程之循環服務器

chenjin_zhong 2020-02-25 00:09:31

Linux 網絡編程之TCP(上)

chenjin_zhong 2020-02-25 00:09:20

linux網絡編程之socket（六）：利用recv和readn函數實現readline函數

weixin_40093087 2020-02-24 22:43:08

網絡中進程間的通信

weixin_40093087 2020-02-24 22:43:08

linux網絡編程之socket（四）：使用fork併發處理多個client的請求和對等通信p2p

weixin_40093087 2020-02-24 22:43:08

IP和端口間的聯繫

weixin_40093087 2020-02-24 22:43:08