TCP并发服务器的实现

1020阅读　0评论2014-10-28　lt6419
分类：嵌入式

    在网络程序里面,一般来说都是许多客户对应一个服务器，为了处理客户的请求, 对服务端的程序就提出了特殊的要求，这就要求服务器在同一个时刻可以响应多个客户端的请求，也就是所谓的并发服务器。
    对于并发服务器，其核心思想是：每提取一个客户端请求，就创建一个子进程或子线程和客户端交互，这就就使得一个客户端对于一个子进程或者线程单独为其进行服务，当多个客户端同时请求服务器时，在服务器上就会有多个多个进程或者线程运行，此时通过CPU的调度算法可以让这些进程、线程轮流执行(单CPU)，即：宏观上并行，微观上串行；或者对于多CPU的情况，就会出现真正的并行执行，此时，服务器可以响应各个客户端的请求，以上就是并发服务器的基本原理。
    TCP的并发服务器可以使用多进程实现，也可以使用多线程实现；
    1.多进程实现的基本流程如下：
    socket(...);
    bind(...);
    listen(...);
    while(1) {
    accept(...);
    if(fork(..)==0) {
    process(...);
    close(...);
    exit(...);
    }
    close(...);
    }
    
    2.多线程实现的基本流程如下：
    socket(...);
    bind(...);
    listen(...);
    while(1)
    {
    pconnect_fd = malloc(sizeof(int));

    *pconnect_fd = accept(...);

    ret = pthread_create(&tid,NULL,do_client,pconnect_fd);
    if(ret != 0){

    }

    pthread_detach(tid);
    }

一、多进程实现代码
服务器代码：

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <signal.h>
  4. #include <sys/socket.h>
  5. #include <netinet/in.h>
  6. #include <arpa/inet.h>


  9. int do_client(int connect_fd)
  10. {
  11.     int n;
  12.     char buf[1024];
  13.     
  14.     while(1)
  15.     {
  16.         n = read(connect_fd,buf,sizeof(buf) - 1);
  17.         if(n <= 0)
  18.             break;

  20.         buf[n] = '\0';
  21.         printf("Read %d bytes : %s\n",n,buf);
  22.     
  23.         if(strncmp(buf,"quit",4)==0)
  24.             break;
  25.     }

  27.     //子进程中如果输入“quit”，则子进程必须要结束运行，然后让父进程进行收尸
  28.     exit(EXIT_SUCCESS);
  29. }

  31. //./server ip port
  32. int main(int argc, const char *argv[])
  33. {
  34.     int pid;
  35.     int sockfd;
  36.     int connect_fd;
  37.     struct sockaddr_in server_addr;
  38.     struct sockaddr_in peer_addr;
  39.     socklen_t addrlen = sizeof(struct sockaddr);

  41.     if(argc < 3)
  42.     {
  43.         fprintf(stderr,"Usage : %s \n",argv[0]);
  44.         exit(EXIT_FAILURE);
  45.     }

  47.     //防止僵尸态的子进程出现。
  48.     //设置SIGCHLD信号处理方式:忽略(告诉内核，子进程结束的时候，系统自动回收僵尸态)
  49.     if(signal(SIGCHLD,SIG_IGN) == SIG_ERR)
  50.     {
  51.         perror("Fail to signal");
  52.         exit(EXIT_FAILURE);
  53.     }

  55.     //1.创建流式套接字
  56.     sockfd = socket(AF_INET,SOCK_STREAM,0);
  57.     if(sockfd < 0){
  58.         perror("Fail to socket");
  59.         exit(EXIT_FAILURE);
  60.     }

  62.     //2.填充服务器的IP地址和端口信息
  63.     server_addr.sin_family = AF_INET;
  64.     server_addr.sin_port = htons(atoi(argv[2]));
  65.     server_addr.sin_addr.s_addr = inet_addr(argv[1]);
  66.     //3.把服务器的IP地址和端口信息和套接字进行绑定
  67.     if(bind(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr)) < 0)
  68.     {
  69.         perror("Fail to bind");
  70.         exit(EXIT_FAILURE);
  71.     }

  73.     //4.设置套接字为监听模式
  74.     listen(sockfd,128);

  76.     printf("listen ...\n");

  78.     while(1)
  79.     {
  80.         //5.提取请求
  81.         connect_fd = accept(sockfd,(struct sockaddr *)&peer_addr,&addrlen);
  82.         if(connect_fd < 0){
  83.             perror("Fail to accept");
  84.             exit(EXIT_FAILURE);
  85.         }

  87.         printf("connect_fd : %d\n",connect_fd);

  89.         printf("-----------------------------\n");
  90.         printf("Port : %d\n",ntohs(peer_addr.sin_port));
  91.         printf("Ip : %s\n",inet_ntoa(peer_addr.sin_addr));
  92.         printf("-----------------------------\n");

  94.         //6.请求提取成功之后立刻创建子进程，让子进程来处理该客户端，如果有多个客户端请求，就
  95.         // 需要创建多个子进程。
  96.         pid = fork();
  97.         if(pid < 0){
  98.             perror("Fail to fork");
  99.             exit(EXIT_FAILURE);
  100.         }

  102.         if(pid == 0)
  103.         {
  104.             //子进程关闭拷贝的父进程中没用的文件描述符
  105.             close(sockfd);
  106.             //在子进程中读取客户端的数据
  107.             do_client(connect_fd);
  108.         }
  109.     
  110.         //防止文件描述符浪费
  111.         close(connect_fd);
  112.     }
  113.     
  114.     return 0;
  115. }
客户端代码：

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/socket.h>
  4. #include <netinet/in.h>
  5. #include <arpa/inet.h>

  7. //./server ip port
  8. int main(int argc, const char *argv[])
  9. {
  10.     int n;
  11.     int sockfd;
  12.     int connect_fd;
  13.     char buf[1024];
  14.     struct sockaddr_in server_addr;
  15.     struct sockaddr_in peer_addr;
  16.     socklen_t addrlen = sizeof(struct sockaddr);

  18.     if(argc < 3)
  19.     {
  20.         fprintf(stderr,"Usage : %s \n",argv[0]);
  21.         exit(EXIT_FAILURE);
  22.     }

  24.     //1.创建套接字
  25.     sockfd = socket(AF_INET,SOCK_STREAM,0);
  26.     if(sockfd < 0){
  27.         perror("Fail to socket");
  28.         exit(EXIT_FAILURE);
  29.     }

  31.     //2.填充服务器的IP地址和端口信息
  32.     server_addr.sin_family = AF_INET;
  33.     server_addr.sin_port = htons(atoi(argv[2]));
  34.     server_addr.sin_addr.s_addr = inet_addr(argv[1]);
  35.     
  36.     //3.和服务器进行连接，实质上是进行3次握手，连接成功之后，被连接的套接字就会变成连接套接字
  37.     // 这个连接套接字就能够和服务器进行通信
  38.     if(connect(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr)) < 0)
  39.     {
  40.         perror("Fail to connect");
  41.         exit(EXIT_FAILURE);
  42.     }

  44.     //4.连接成功之后，向服务器端发送数据
  45.     while(1)
  46.     {
  47.         printf("client >");
  48.         fgets(buf,sizeof(buf),stdin);
  49.         buf[strlen(buf) - 1] = '\0';

  51.         n = write(sockfd,buf,strlen(buf));
  52.         if(n < 0){
  53.             perror("Fail to write");
  54.             exit(EXIT_FAILURE);
  55.         }
  56.     }
  57.     
  58.     return 0;
  59. }
运行测试结果如下：

点击(此处)折叠或打开

  1. ubuntu@ubuntu:~/network_teacher/day02/tcp1/client$ ./client 192.168.127.131 8888
  2. client >hello
  3. client >world
  4. client >quit
  5. client >quit
  6. client >quit
  7. ubuntu@ubuntu:~/network_teacher/day02/tcp1/client$

点击(此处)折叠或打开

  1. ubuntu@ubuntu:~/network_teacher/day02/tcp1/server$ ./server 192.168.127.131 8888
  2. listen ...
  3. connect_fd : 4
  4. -----------------------------
  5. Port : 53987
  6. Ip : 192.168.127.131
  7. -----------------------------
  8. Read 5 bytes : hello
  9. Read 5 bytes : world
  10. Read 4 bytes : quit
 二、多线程实现代码
    客户端的代码完全相同，服务器端的代码做少量的修改，代码如下：

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <signal.h>
  4. #include <pthread.h>
  5. #include <string.h>
  6. #include <sys/socket.h>
  7. #include <netinet/in.h>
  8. #include <arpa/inet.h>


  11. void *do_client(void *arg)
  12. {
  13.     int n;
  14.     int connect_fd = *((int *)arg);
  15.     char buf[1024];
  16.     
  17.     while(1)
  18.     {
  19.         n = read(connect_fd,buf,sizeof(buf) - 1);
  20.         if(n <= 0)
  21.             break;

  23.         buf[n] = '\0';
  24.         printf("Read %d bytes : %s\n",n,buf);
  25.     
  26.         if(strncmp(buf,"quit",4)==0)
  27.             break;
  28.     }

  30.     //线程处理完之后必须关闭线程要操作的文件描述符，释放分配的内存空间
  31.     close(connect_fd);
  32.     free(arg);

  34.     //线程退出
  35.     pthread_exit(NULL);
  36. }

  38. //./server ip port
  39. int main(int argc, const char *argv[])
  40. {
  41.     int ret;
  42.     int pid;
  43.     int sockfd;
  44.     int *pconnect_fd;
  45.     pthread_t tid;
  46.     struct sockaddr_in server_addr;
  47.     struct sockaddr_in peer_addr;
  48.     socklen_t addrlen = sizeof(struct sockaddr);

  50.     if(argc < 3)
  51.     {
  52.         fprintf(stderr,"Usage : %s \n",argv[0]);
  53.         exit(EXIT_FAILURE);
  54.     }

  56.     //1.创建套接字
  57.     sockfd = socket(AF_INET,SOCK_STREAM,0);
  58.     if(sockfd < 0){
  59.         perror("Fail to socket");
  60.         exit(EXIT_FAILURE);
  61.     }

  63.     //2.填充服务器的Ip和端口信息
  64.     server_addr.sin_family = AF_INET;
  65.     server_addr.sin_port = htons(atoi(argv[2]));
  66.     server_addr.sin_addr.s_addr = inet_addr(argv[1]);
  67.     //3.绑定服务器的IP地址和端口信息到套接字
  68.     if(bind(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr)) < 0)
  69.     {
  70.         perror("Fail to bind");
  71.         exit(EXIT_FAILURE);
  72.     }
  73.     
  74.     //4.设置套接字为监听模式
  75.     listen(sockfd,128);

  77.     printf("listen ...\n");

  79.     while(1)
  80.     {
  81.         pconnect_fd = (int *)malloc(sizeof(int));
  82.         if(pconnect_fd == NULL){
  83.             perror("Fail to malloc");
  84.             exit(EXIT_FAILURE);
  85.         }

  87.         //5.从请求队列中提取请求
  88.         *pconnect_fd = accept(sockfd,(struct sockaddr *)&peer_addr,&addrlen);
  89.         if(connect_fd < 0){
  90.             perror("Fail to accept");
  91.             exit(EXIT_FAILURE);
  92.         }

  94.         printf("connect_fd : %d\n",*pconnect_fd);
  95.         printf("-----------------------------\n");
  96.         printf("Port : %d\n",ntohs(peer_addr.sin_port));
  97.         printf("Ip : %s\n",inet_ntoa(peer_addr.sin_addr));
  98.         printf("-----------------------------\n");
  99.         
  100.         //6.提取请求成功之后立刻创建线程，每个客户端的请求都对于一个新创建的线程
  101.         ret = pthread_create(&tid,NULL,do_client,pconnect_fd);
  102.         if(ret != 0){
  103.             fprintf(stderr,"Fail to pthread_create : %s\n",strerror(ret));
  104.         }

  106.         //分离式线程:系统自动回收，线程结束的时候未释放的资源
  107.         pthread_detach(tid);
  108.     }
  109.     
  110.     return 0;
  111. }
    测试结果和多进程的结果相同。
上一篇：基于TCP的客户端--服务器
下一篇：Linux I2C驱动分析(一)----I2C架构和总线驱动