备案控制台
探索云世界
开发者社区 云计算 文章 正文

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

2018-09-19 1771
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 这篇主要介绍如何实现并发服务器，主要通过三种方式：进程、线程和select函数来分别实现。

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

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

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

先简单说下原理吧，先画个图，如下：
_1
先要搞清楚通信的流程，图上参数说明：

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

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

　　server：服务器

　　client：客户端

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

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

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

现在问题就是。如何创建多个进程与客户端通信呢？通过循环创建子进程就可以实现这个问题

服务端程序，如下：

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

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

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

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

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

这张图将三次握手、四次挥手和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/9664204.html
推荐阅读：https://www.roncoo.com/article/index?title=%E5%B9%B6%E5%8F%91

文章标签：
网络协议
关键词：
线程并发
线程服务器
并发线程
进程线程
并发云服务器 ECS
调皮仔3683
目录
相关文章
1941623231718325
|
13天前
|
安全 Java 数据处理
Python网络编程基础（Socket编程）多线程/多进程服务器编程
【4月更文挑战第11天】在网络编程中，随着客户端数量的增加，服务器的处理能力成为了一个重要的考量因素。为了处理多个客户端的并发请求，我们通常需要采用多线程或多进程的方式。在本章中，我们将探讨多线程/多进程服务器编程的概念，并通过一个多线程服务器的示例来演示其实现。
1941623231718325
31 0
qtuzunbex43fk
|
1月前
|
弹性计算
阿里云3M带宽云服务器并发多大？阿里云3M带宽云服务器测评参考
在探讨云服务器3M带宽能支持多大并发这一问题时，我们首先要明白一个关键点：并发量并非仅由带宽决定，还与网站本身的大小密切相关。一般来说，一个优化良好的普通网站页面大小可能只有几K，为便于计算，我们可以暂且假定每个页面大小为50K。
qtuzunbex43fk
819 1
桃李春风一杯酒
|
5天前
|
安全 Java
深入理解 Java 多线程和并发工具类
【4月更文挑战第19天】本文探讨了Java多线程和并发工具类在实现高性能应用程序中的关键作用。通过继承`Thread`或实现`Runnable`创建线程，利用`Executors`管理线程池，以及使用`Semaphore`、`CountDownLatch`和`CyclicBarrier`进行线程同步。保证线程安全、实现线程协作和性能调优（如设置线程池大小、避免不必要同步）是重要环节。理解并恰当运用这些工具能提升程序效率和可靠性。
桃李春风一杯酒
13 0
技术混子
|
7天前
|
Java 开发者
Java中多线程并发控制的实现与优化
【4月更文挑战第17天】 在现代软件开发中，多线程编程已成为提升应用性能和响应能力的关键手段。特别是在Java语言中，由于其平台无关性和强大的运行时环境，多线程技术的应用尤为广泛。本文将深入探讨Java多线程的并发控制机制，包括基本的同步方法、死锁问题以及高级并发工具如java.util.concurrent包的使用。通过分析多线程环境下的竞态条件、资源争夺和线程协调问题，我们提出了一系列实现和优化策略，旨在帮助开发者构建更加健壮、高效的多线程应用。
技术混子
7 0
桃李春风一杯酒
|
10天前
|
Java API 调度
安卓多线程和并发处理：提高应用效率
【4月更文挑战第13天】本文探讨了安卓应用中多线程和并发处理的优化方法，包括使用Thread、AsyncTask、Loader、IntentService、JobScheduler、WorkManager以及线程池。此外，还介绍了RxJava和Kotlin协程作为异步编程工具。理解并恰当运用这些技术能提升应用效率，避免UI卡顿，确保良好用户体验。随着安卓技术发展，更高级的异步处理工具将助力开发者构建高性能应用。
桃李春风一杯酒
29 5
技术混子
|
23天前
|
安全 Java
Java中的多线程并发控制
在Java中，多线程是实现并发执行任务的一种重要方式。然而，随着多个线程同时访问共享资源，可能会导致数据不一致和其他并发问题。因此，了解并掌握Java中的多线程并发控制机制显得尤为重要。本文将深入探讨Java的多线程并发控制，包括synchronized关键字、Lock接口、Semaphore类以及CountDownLatch类等，并通过实例代码演示其使用方法和注意事项。
技术混子
12 2
泡沫o0
|
30天前
|
算法 安全 Unix
【C++ 20 信号量 】C++ 线程同步新特性 C++ 20 std::counting_semaphore 信号量的用法 控制对共享资源的并发访问
【C++ 20 信号量 】C++ 线程同步新特性 C++ 20 std::counting_semaphore 信号量的用法 控制对共享资源的并发访问
泡沫o0
30 0
泡沫o0
|
1月前
|
负载均衡 Java 数据处理
【C++ 并发 线程池】轻松掌握C++线程池：从底层原理到高级应用（三）
【C++ 并发 线程池】轻松掌握C++线程池：从底层原理到高级应用
泡沫o0
52 2
泡沫o0
|
1月前
|
存储 监控 Java
【C++ 并发 线程池】轻松掌握C++线程池：从底层原理到高级应用（二）
【C++ 并发 线程池】轻松掌握C++线程池：从底层原理到高级应用
泡沫o0
42 1
泡沫o0
|
1月前
|
负载均衡 安全 Java
【C++ 并发 线程池】轻松掌握C++线程池：从底层原理到高级应用（一）
【C++ 并发 线程池】轻松掌握C++线程池：从底层原理到高级应用
泡沫o0
57 2

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    【Qt 底层之事件驱动系统】深入理解 Qt 事件机制：主事件循环与工作线程的交互探究，包括 QML 的视角
  • 3
    【C/C++ 单线程性能分析工具 Gprof】 GNU的C/C++ 性能分析工具 Gprof 使用全面指南
  • 4
    Python 学习之路 01基础入门---【Python安装，Python程序基本组成】
  • 5
    【深入探究 Qt 线程】一文详细解析Qt线程的内部原理与实现策略
  • 6
    【C/C++ 线程池设计思路】 深入探索线程池设计：任务历史记录的高效管理策略
  • 7
    【C++ const 函数 的使用】C++ 中 const 成员函数与线程安全性：原理、案例与最佳实践
  • 8
    深入理解Java并发编程：线程安全与性能优化
  • 9
    【C++ 线程包裹类设计】跨平台C++线程包装类：属性设置与平台差异的全面探讨
  • 10
    Python学习之路 02 之分支结构
  • 1
    服务器数据恢复—昆腾存储StorNext文件系统数据恢复案例
    10
  • 2
    ECS使用体验
    18
  • 3
    Servlet 教程 之 Servlet 服务器 HTTP 响应 3
    14
  • 4
    Windows如何远程连接服务器？服务器远程连接图文教程
    18
  • 5
    什么情况下物理服务器会运行出错？
    28
  • 6
    ECS使用体验
    27
  • 7
    反向代理服务器如何提升信息安全
    19
  • 8
    IDEA通过内网穿透实现固定公网地址远程SSH连接本地Linux服务器
    21
  • 9
    阿里云服务器经济型e、通用算力型u1与c7/g7/r7/c8y/g8y/r8y实例区别及选择参考
    28
  • 10
    体验版小程序为何无法访问云端服务器后端接口（请求失败...（已完美解决附加图片））？
    12

    • 相关课程

    更多
  • ECS上云入门三部曲
  • 服务器硬件基础
  • Linux Web服务器Nginx搭建与配置
  • 7天玩转云服务器
  • 云服务器选型、迁云最佳实践
  • 云服务器ECS基本操作

    • 相关电子书

    更多
  • 如何运维千台以上游戏云服务器
  • 网站/服务器取证 实践与挑战
  • ECS快储存加密技术

    • 相关实验场景

    更多
  • 使用阿里云ECS监控您的特斯拉
  • 使用阿里云ECS安装家用内网穿透服务
  • ECS实例选型最佳实践
  • ECS服务保活和宕机启动
  • 云原生场景自动化响应ECS系统事件
  • 幻兽帕鲁联机服务快速部署【有ECS用户】
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）