并发服务器三种实现方式之进程、线程和select

　　前言：刚开始学网络编程，都会先写一个客户端和服务端，不知道你们有没有试一下：再打开一下客户端，是连不上服务端的。还有一个问题不知道你们发现没：有时启服务器，会提示“Address already in use”，过一会就好了，想过为啥么？在这篇博客会解释这个问题。

　　但现实的服务器都会连很多客户端的，像阿里服务器等，所以这篇主要介绍如何实现并发服务器，主要通过三种方式：进程、线程和select函数来分别实现。

　　一、进程实现并发服务器

　　先说下什么是并发服务器吧？不是指有多个服务器同时运行，而是可以同时连接多个客户端。

　　先简单说下原理吧，先画个图，如下：　　PS：全博客园最丑图，不接受反驳！哈哈哈

　　

　　先要搞清楚通信的流程，图上参数说明：

　　lfd：socket函数的返回值，就是监听描述符

　　cfd1/cfd2/cfd3:accept函数的返回值，用通信的套接字

　　server：服务器

　　client：客户端

　　socket通信过程中，总共有几个套接字呢？答：三个，客户端一个，服务器两个。

　　根据上图来大致说明一下流程：

　　客户端创建一个套接字描述符，用于通信，服务器先用socket函数创建套接字，用于监听客户端，然后调用accept函数，会返回一个套接字，用于通信的。图上就是，client1先通过cfd与server建立连接，然后与cfd1建立连接通信，这时lfd就空闲了，再监听客户端，client2再与lfd连接，再跟cfd2通信。client3也是如此。

　　现在问题就是。如何创建多个进程与客户端通信呢？通过循环创建子进程就可以实现这个问题，可以参考我的这篇博客：https://www.cnblogs.com/liudw-0215/p/9667686.html

　　服务端程序，如下：

　　

#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>
#include <ctype.h>
#include <unistd.h>

#include "wrap.h"

#define MAXLINE 8192
#define SERV_PORT 8000

void do_sigchild(int num)
{
    while (waitpid(0, NULL, WNOHANG) > 0)
        ;
}

int main(void)
{
    struct sockaddr_in servaddr, cliaddr;
    socklen_t cliaddr_len;
    int listenfd, connfd;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN];
    int i, n;
    pid_t pid;
    struct sigaction newact;

    newact.sa_handler = do_sigchild;
    sigemptyset(&newact.sa_mask);
    newact.sa_flags = 0;
    sigaction(SIGCHLD, &newact, NULL);    //建立信号，处理子进程退出

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

    // int opt = 1;
    //setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));    //端口复用

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);

    Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    Listen(listenfd, 20);

    printf("Accepting connections ...\n");
    while (1) {
        cliaddr_len = sizeof(cliaddr);
        connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
        pid = fork();
        if (pid == 0) {
            Close(listenfd);
            while (1) {
                n = Read(connfd, buf, MAXLINE);
                if (n == 0) {
                    printf("the other side has been closed.\n");
                    break;
                }
                printf("received from %s at PORT %d\n",
                        inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),ntohs(cliaddr.sin_port));
                for (i = 0; i < n; i++)
                    buf[i] = toupper(buf[i]);
                Write(STDOUT_FILENO, buf, n);
                Write(connfd, buf, n);
            }
            Close(connfd);
            return 0;
        } else if (pid > 0) {
            Close(connfd);
        }  else
            perr_exit("fork");
    }
    return 0;
}

　　客户端程序如下：

　　

/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "wrap.h"

#define MAXLINE 8192
#define SERV_PORT 8000

int main(int argc, char *argv[])
{
    struct sockaddr_in servaddr;
    char buf[MAXLINE];
    int sockfd, n;

    sockfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
    servaddr.sin_port = htons(SERV_PORT);

    Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    while (fgets(buf, MAXLINE, stdin) != NULL) {
        Write(sockfd, buf, strlen(buf));
        n = Read(sockfd, buf, MAXLINE);
        if (n == 0) {
            printf("the other side has been closed.\n");
            break;
        }
        else
            Write(STDOUT_FILENO, buf, n);
    }

    Close(sockfd);

    return 0;
}

　　演示效果，服务器可以同时处理两个客户端，如下：

　　

　　但我想再测试一下程序，执行./server,发现有个bind error,如下：

　　

　　下面来解释一下这个问题：

　　先来一张图片（出自UNP），如下：

　　

　　这张图将三次握手、四次挥手和TCP状态转换图，这些在我的这篇博客都由介绍，可以参考一下：https://www.cnblogs.com/liudw-0215/p/9661583.html

注意最后有一个TIME_WAIT状态，主动关闭一端会经历2MSL时长等待（大约40秒），再变为最开始的状态CLOSED。

　　复现上面的“bind error”，只需退出服务器，在启服务器，就会报出此错。因为主动关闭一端，会经历2MSL时长，端口IP会被占用，所以会报“bind error”。

但可能会问：为啥先退出客户端没有此问题？因为客户端没有调用bind函数地址结构，会“隐式”生成端口。

　　有没有方法可以解决这个问题呢？当然有的，调用函数setsockopt即可，服务端程序如下：

　　

#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>
#include <ctype.h>
#include <unistd.h>

#include "wrap.h"

#define MAXLINE 8192
#define SERV_PORT 8000

void do_sigchild(int num)
{
    while (waitpid(0, NULL, WNOHANG) > 0)
        ;
}

int main(void)
{
    struct sockaddr_in servaddr, cliaddr;
    socklen_t cliaddr_len;
    int listenfd, connfd;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN];
    int i, n;
    pid_t pid;
    struct sigaction newact;

    newact.sa_handler = do_sigchild;
    sigemptyset(&newact.sa_mask);
    newact.sa_flags = 0;
    sigaction(SIGCHLD, &newact, NULL);    //建立信号，处理子进程退出

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));    //端口复用

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);

    Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    Listen(listenfd, 20);

    printf("Accepting connections ...\n");
    while (1) {
        cliaddr_len = sizeof(cliaddr);
        connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
        pid = fork();
        if (pid == 0) {
            Close(listenfd);
            while (1) {
                n = Read(connfd, buf, MAXLINE);
                if (n == 0) {
                    printf("the other side has been closed.\n");
                    break;
                }
                printf("received from %s at PORT %d\n",
                        inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),ntohs(cliaddr.sin_port));
                for (i = 0; i < n; i++)
                    buf[i] = toupper(buf[i]);
                Write(STDOUT_FILENO, buf, n);
                Write(connfd, buf, n);
            }
            Close(connfd);
            return 0;
        } else if (pid > 0) {
            Close(connfd);
        }  else
            perr_exit("fork");
    }
    return 0;
}

　　二、线程实现并发服务器

　　理解了进程的方式，就是创建多个线程来实现，就不过多解释了，程序需要对线程有一定了解，之后我还会写篇博客来介绍线程，敬请期待哦。

　　服务器代码如下，有有详细的解释：

　　

#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>

#include "wrap.h"

#define MAXLINE 8192
#define SERV_PORT 8000

struct s_info {                     //定义一个结构体, 将地址结构跟cfd捆绑
    struct sockaddr_in cliaddr;
    int connfd;
};

void *do_work(void *arg)
{
    int n,i;
    struct s_info *ts = (struct s_info*)arg;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN];      //#define INET_ADDRSTRLEN 16  可用"[+d"查看

    while (1) {
        n = Read(ts->connfd, buf, MAXLINE);                     //读客户端
        if (n == 0) {
            printf("the client %d closed...\n", ts->connfd);
            break;                                              //跳出循环,关闭cfd
        }
        printf("received from %s at PORT %d\n",
                inet_ntop(AF_INET, &(*ts).cliaddr.sin_addr, str, sizeof(str)),
                ntohs((*ts).cliaddr.sin_port));                 //打印客户端信息(IP/PORT)

        for (i = 0; i < n; i++)
            buf[i] = toupper(buf[i]);                           //小写-->大写

        Write(STDOUT_FILENO, buf, n);                           //写出至屏幕
        Write(ts->connfd, buf, n);                              //回写给客户端
    }
    Close(ts->connfd);

    return (void *)0;
}

int main(void)
{
    struct sockaddr_in servaddr, cliaddr;
    socklen_t cliaddr_len;
    int listenfd, connfd;
    pthread_t tid;
    struct s_info ts[256];      //根据最大线程数创建结构体数组.
    int i = 0;

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);                     //创建一个socket, 得到lfd

    bzero(&servaddr, sizeof(servaddr));                             //地址结构清零
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);                   //指定本地任意IP
    servaddr.sin_port = htons(SERV_PORT);                           //指定端口号 8000

    Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)); //绑定

    Listen(listenfd, 128);      //设置同一时刻链接服务器上限数

    printf("Accepting client connect ...\n");

    while (1) {
        cliaddr_len = sizeof(cliaddr);
        connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);   //阻塞监听客户端链接请求
        ts[i].cliaddr = cliaddr;
        ts[i].connfd = connfd;

        /* 达到线程最大数时，pthread_create出错处理, 增加服务器稳定性 */
        pthread_create(&tid, NULL, do_work, (void*)&ts[i]);
        pthread_detach(tid);                                                    //子线程分离,防止僵线程产生.
        i++;
    }

    return 0;
}

　　客户端代码如下：

　　

/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8000

int main(int argc, char *argv[])
{
    struct sockaddr_in servaddr;
    char buf[MAXLINE];
    int sockfd, n;

    sockfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr.s_addr);
    servaddr.sin_port = htons(SERV_PORT);

    Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    while (fgets(buf, MAXLINE, stdin) != NULL) {
        Write(sockfd, buf, strlen(buf));
        n = Read(sockfd, buf, MAXLINE);
        if (n == 0)
            printf("the other side has been closed.\n");
        else
            Write(STDOUT_FILENO, buf, n);
    }

    Close(sockfd);

    return 0;
}

　　三、select实现并发服务器

　　select和进程主要区别在于，进程是阻塞的，而select是交给内核自己来实现的，由于select比较复杂，参考我的另一篇博客：https://www.cnblogs.com/liudw-0215/p/9661583.html

　　总结：有不懂的，欢迎及时评论。

　　

　　

　　

原文地址：https://www.cnblogs.com/liudw-0215/p/9664204.html

时间： 2024-07-29 15:43:09

并发服务器三种实现方式之进程、线程和select的相关文章

MyEclipse中web服务器的三种配置方式

初学Javaweb开发的人们都会遇到一个问题,就是服务器环境的搭建配置问题.下面介绍三种服务器的搭建方式. 直接修改server.xml文件 当你写了一个web应用程序(jsp/servlet),想通过浏览器直接去访问这个页面,需要在Tomcat中配置相关路径: 找到Tomcat下conf目录,你会看到有个server.xml,即服务器配置文件.用文本编译器打开,拉到Host标签,在它结束前加上我们的应用程序路径: <Context path="/HelloWeb" docBas

分布式锁简单入门以及三种实现方式介绍

前言 很多小伙伴在学习Java的时候,总是感觉Java多线程在实际的业务中很少使用,以至于不会花太多的时间去学习,技术债不断累积!等到了一定程度的时候对于与Java多线程相关的东西就很难理解,今天需要探讨的东西也是一样的和Java多线程相关的!做好准备,马上开车! 学过Java多线程的应该都知道什么是锁,没学过的也不用担心,Java中的锁可以简单的理解为多线程情况下访问临界资源的一种线程同步机制. 在学习或者使用Java的过程中进程会遇到各种各样的锁的概念:公平锁.非公平锁.自旋锁.可重入锁.偏

Apache HTTP Server 与 Tomcat 的三种连接方式介绍

Apache HTTP Server 与 Tomcat 的三种连接方式介绍 整合 Apache Http Server 和 Tomcat 可以提升对静态文件的处理性能.利用 Web 服务器来做负载均衡以及容错.无缝的升级应用程序.本文介绍了三种整合 Apache 和 Tomcat 的方式. 3 评论: 刘 冬 ([email protected]), 开发工程师, 2007 年 1 月 15 日 内容 首先我们先介绍一下为什么要让 Apache 与 Tomcat 之间进行连接.事实上 Tomca

IIS下PHP的三种配置方式比较

在Windows IIS 6.0下配置PHP,通常有CGI.ISAPI和FastCGI三种配置方式,这三种模式都可以在IIS 6.0下成功运行,下面我就讲一下这三种方式配置的区别和性能上的差异. 1.CGI(通用网关接口/Common Gateway Interface)一般是可执行程序,例如EXE文件,和WEB服务器各自占据着不同的进程,而且一般一个CGI程序只能处理一个用户请求.这样,当用户请求数量非常多时,会大量占用系统的资源,如内存.CPU时间等,造成效能低下. 2.ISAPI(Inte

Linq to Sql : 三种事务处理方式

原文:Linq to Sql : 三种事务处理方式 Linq to SQL支持三种事务处理模型:显式本地事务.显式可分发事务.隐式事务.(from  MSDN: 事务 (LINQ to SQL)).MSDN中描述得相对比较粗狂,下面就结合实例来对此进行阐述. 0. 测试环境 OS Windows Server 2008 Enterprise + sp1 IDE Visual Studio 2008, .net framework 3.5 + SP1 DB SQL Server 2000 + sp

Hive metastore三种配置方式

本文转载至:http://blog.csdn.net/reesun/article/details/8556078 目录(?)[-] 一本地derby 二本地mysql 三远端mysql 1服务端配置文件 2客户端配置文件 Hive的meta数据支持以下三种存储方式,其中两种属于本地存储,一种为远端存储.远端存储比较适合生产环境.Hive官方wiki详细介绍了这三种方式,链接为:Hive Metastore. 一.本地derby 这种方式是最简单的存储方式,只需要在hive-site.xml做如

lamp平台三种实现方式

lamp平台的安装实现方式分为三种:rpm包的方式安装,以模块的方式编译安装,以fpm方式工作编译安装的php. 一.rpm包安装php: 在CentOS 6.5系统上以rpm包的方式安装httpd,php,mysq是最容易的一种,php在这种情况下做为httpd的模块来运行,在安装完php对应的rpm包以后,可以在httpd的配置文件目录中查看到php.conf文件,配置文件中定义了加载php模块对应的库文件的定义.当httpd启动进程响应客户的请求时,如果客户端请求的是php页面文件,那么h

jenkins介绍部署及三种构建方式配置

[隐藏] 1前言 1.1jenkins介绍 1.2jenkins好处 1.3我的jenkins实践 1.4jenkins使用前提 2jenkins部署 2.1下面内容介绍 2.2环境介绍 2.3jenkins安装 3插件安装 3.1手动下载jenkins插件 4Jenkins密钥配置 5jenkins触发式构建 6jenkins参数化构建 7jenkins定时构建 8Jenkins用户权限设置 8.1新创建一个用户 8.2用户权限设置 1.前言 1.1.jenkins介绍 jenkins是基于j

cookie 和 session的区别 &amp; 三种传值方式

1.session保存在服务器,客户端不知道其中的信息:cookie保存在客户端,服务器能够知道其中的信息. 2.session中保存的是对象,cookie中保存的是字符串. 3.session不能区分路径,同一个用户在访问一个网站期间,所有的session在任何一个地方都可以访问到.而cookie中如果设置了路径参数,那么同一个网站中不同路径下的cookie互相是访问不到的. 4.session以cookie为基础,session需要借助cookie才能正常工作,如果客户端完全禁止cookie