Linux网络编程：多路转接|select|poll

最新推荐文章于 2024-11-02 10:43:50 发布
最新推荐文章于 2024-11-02 10:43:50 发布
阅读量623 收藏 8
点赞数 9
分类专栏： Linux学习 文章标签： 服务器 运维 网络 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73234157/article/details/139655634
版权

目录

前言：

1.IO多路转接---select

1.1.接口认识

1.2.select如何进行多路转接

1.3.select多路转接的优缺点

2.IO多路转接---poll

2.1.接口认识

2.2.poll如何进行多路转接

2.3.poll多路转接优缺点

前言：

多路转接（也称为IO多路复用）是一种网络通信的手段或机制，它允许一个进程同时监听多个IO事件，并在任何一个IO事件准备就绪时进行处理。这种机制可以大大提高程序的并发性能和响应速度。以下是关于多路转接的详细解释：

  1. 定义：
    • 多路转接是一种IO模型，它允许单个进程或线程同时监听多个文件描述符（如套接字、管道等）的状态变化，从而能够处理多个IO事件。
  2. 核心特点：
    • 并发性：通过同时监听多个文件描述符，多路转接可以在单线程/进程的场景下实现并发处理。
    • 非阻塞：在监听过程中，进程/线程不会被阻塞，直到有文件描述符就绪。
    • 事件驱动：当某个文件描述符的状态发生变化（如可读、可写等）时，多路转接会触发相应的事件处理函数。
  3. 常见实现方式：
    • select：Unix系统中最早引入的多路复用IO机制之一，它允许程序同时监听多个文件描述符上的IO事件。
    • poll：与select类似，但提供了更灵活的监听方式，并且可以处理更多的文件描述符。
    • epoll：Linux特有的IO多路复用机制，相比select和poll具有更高的性能和更好的扩展性。
  4. 应用场景：
    • 当客户需要处理多个描述符（如交互式输入和网络套接字）时。
    • 一个客户同时处理多个套接字时。
    • 一个TCP服务器既要处理监听套接字，又要处理已连接套接字时。
    • 一个服务器需要处理多种服务或协议时。
  5. 优势：
    • 与多进程和多线程技术相比，IO多路复用技术的最大优势是系统开销小。系统不必创建和维护大量的进程/线程，从而大大减小了系统的开销。
  6. 工作原理：
    • 使用IO多路转接函数（如select、poll、epoll）委托内核检测服务器端所有的文件描述符。
    • 如果检测到已就绪的文件描述符，阻塞会解除，并将这些已就绪的文件描述符传出。
    • 根据类型对传出的所有已就绪文件描述符进行判断，并做出不同的处理（如接受新连接、读取数据、发送数据等）。

总结来说，多路转接是一种高效的网络通信手段，它通过允许单个进程或线程同时监听多个IO事件，实现了在单线程/进程场景下的并发处理。这种机制在高性能网络服务器、并发编程等领域有着广泛的应用。

1.IO多路转接---select

1.1.接口认识

我们在1.4中提及了select通过监听大量的IO通道来实现高效的IO，select只负责IO过程中的等待，当等待结束，相应的条件就绪时，负责拷贝的函数就不需要进行等待而是直接完成IO。而select是系统提供的一个IO多路复用的系统调用。

  • 事件：一个文件描述符上的事件，一般分为：读事件、写事件、异常事件。读事件就绪，表示可读，缓冲区存在数据。写事件就绪，表示可写，缓冲区有空间。异常事件，表示读取到文件描述符出现异常。
  •  文件描述符的集合，为输入输出型参数，fd_set类型本质上是一张位图，比特位的位置表示文件描述符的值。当进行输入时：比特位0或者1表示是否关心相应事件。当输出时，内核告知用户那些fd上面的事件是否就绪。
  • select的返回值有三种，大于0表示：select等待的文件描述符中，已经就绪的文件描述符的个数。等于0表示：select超时返回。小于0表示：出错了。
  • 对于timeout，设置为{0,0}表示为非阻塞，设置为{5,0}表示非阻塞等待5s，设置为nullptr表示阻塞。

对文件描述符集合专门的调整函数！！！ 

void FD_CLR(int fd, fd_set *set);     // 用来清除描述词组set中相关fd 的位
int FD_ISSET(int fd, fd_set *set);    // 用来测试描述词组set中相关fd 的位是否为真
void FD_SET(int fd, fd_set *set);     // 用来设置描述词组set中相关fd的位
void FD_ZERO(fd_set *set);            // 用来清除描述词组set的全部位

1.2.select如何进行多路转接

该段代码为一个引入select多路转接的TCP服务器，里面包含的头文件socket.hpp和log.hpp的具体代码在select_server模块 - Gitee.com ，

#include <iostream>
#include <memory>
#include <sys/select.h>
#include "Log.hpp"
#include "socket.hpp"

const int default_backlog = 5;
const static int num = sizeof(fd_set) * 8;
class SelectServer
{
private:
    void HanderAccept(const fd_set &set)
    {
        // 可能会处理多个文件描述符

        for (size_t i = 0; i < num; i++)
        {  
            if (_rfds_array[i] == nullptr)
            {
                continue;
            }
            // 合法的套接字
            else
            {
                // 注意这里会出现：1.Accept新链接  2.read获取到新数据
                int fd = _rfds_array[i]->GetSockFd();
                // 判断fd是否在这个集合里
                if (FD_ISSET(fd, &set))
                {
                    // 表示 获取套接字就绪  
                    if (fd == _listen_sock->GetSockFd())
                    {
                        lg.LogMessage(Info, "get a new link\n");
                        std::string client_ip;
                        uint16_t client_port;
                        NetWork::Socket *sock = _listen_sock->AcceptConnection(&client_ip, &client_port);
                        if (sock == nullptr)
                        {
                            lg.LogMessage(Error, "sock accept failed\n");
                        }
                        lg.LogMessage(Info, "connect client success, client info is %s:%d, fd = %d\n", client_ip.c_str(), client_port, sock->GetSockFd());

                        // 建立好了链接，现在不确定读、写事件是否就绪
                        // 所以我们需要对读、写进行select
                        // 此时我们需要将新增的套接字，交由select进行托管
                        int pos = 0;

                        for (; pos < num; pos++)
                        {
                            if (_rfds_array[pos] == nullptr)
                            {
                                _rfds_array[pos] = sock;
                                break;
                            }
                        }
                        if (pos == num)
                        {
                            // 服务器select托管套接字已达上限
                            sock->CloseSockFd();
                            delete sock;
                            lg.LogMessage(Warning, "server is full...\n");
                        }
                    }
                    // 表示 读取数据 就绪, 可以在这里进行IO
                    else
                    {
                        std::string buffer;
                        bool ret = _rfds_array[i]->Recv(&buffer, 1024);
                        if(ret == true)
                        {
                            std::cout<<"client message: "<<buffer<<std::endl;
                            buffer.clear();
                        }
                        else
                        {
                            // 差错处理 client文件描述符关闭 或者是 recv出现错误
                            lg.LogMessage(Error, "recv message failed\n");
                            _rfds_array[i]->CloseSockFd();
                            delete _rfds_array[i];
                            _rfds_array[i] = nullptr;
                        }
                    }
                }
            }
        }
    }

public:
    SelectServer(int port) : _port(port), _listen_sock(new NetWork::TcpSocket()), _isrunning(false) {}

    void InitServer()
    {
        _listen_sock->BuildListenSocketMethod(_port, default_backlog);
        // 初始化话fd数组
        for (size_t i = 0; i < num; i++)
        {
            _rfds_array[i] = nullptr;
        }

        _rfds_array[0] = _listen_sock.get();    // 获取到内部的指针
    }

    void Loop()
    {
        _isrunning = true;
        while (_isrunning == true)
        {
            // accept本质上是一个读事件，所以我们不能先进行accept
            // 而是先进行select监听所有的文件描述符，进行等待
            fd_set rfds;
            FD_ZERO(&rfds);
            // 获取最大的fd然后作为select的参数
            int max_fd = _listen_sock->GetSockFd();
            for (size_t i = 0; i < num; i++)
            {
                if (_rfds_array[i] == nullptr)
                {
                    continue;
                }
                else
                {
                    // 当前文件描述符fd
                    int fd = _rfds_array[i]->GetSockFd();
                    // 需要将文件描述符添加到这个集合中，将新的套接字添加到rfds中
                    FD_SET(fd, &rfds);

                    if (max_fd < fd)
                    {
                        max_fd = fd;
                    }
                }
            }

            struct timeval timeout = {5, 0};
            int n = select(max_fd + 1, &rfds, nullptr, nullptr, &timeout);

            if (n > 0) // select成功
            {
                lg.LogMessage(Info, "select success, last time: %u.%u\n", timeout.tv_sec, timeout.tv_usec);
                // 这里对响应的Accept进行处理
                HanderAccept(rfds);
            }
            else if (n == 0) // select超时
            {
                lg.LogMessage(Info, "select timeout, last time: %u.%u\n", timeout.tv_sec, timeout.tv_usec);
            }
            else // select失败
            {
                lg.LogMessage(Error, "select error\n");
            }
        }
        _isrunning = false;
    }

private:
    std::unique_ptr<NetWork::Socket> _listen_sock;
    int _port;
    bool _isrunning;

    // select服务器需要通过数据结构维护文件描述符
    NetWork::Socket *_rfds_array[num];
};

首先我们要知道select的使用逻辑：

  1. 我们在进行select之前，需要知道在网络通信中IO的场景有什么？一是：服务器、客户端在进行通信之前需要监听、并接收形成新的套接字，需要等待套接字Accept就绪，本质上也是等待读事件就绪。二是：在进行读取数据时，需要等待读事件就绪。
  2. 在知道了select需要等待套接字就绪，我们知道在网络通信中，一台服务器可以接收许多个套接字，也就是套接字可能在循环中不断就绪，所以我们需要动态的更新就绪的套接字，并写入到读集合。
  3. 现在我们结合1，2和TCP的listen套接字，首先对于listen套接字而言，他的select需要等待的是大量的accept获取到的新套接字就绪，而对于这些获取到的新套接字，我们又需要对他们将传来的数据进行等待读事件就绪。这里也体现在我们HandlerAccept函数中分了两种情况进行fd的操作
  4. 值得一提的是：select的本质就是内核帮我们遍历当前的所有套接字查询是否等待条件就绪，并且传入的集合为输入输出型参数，当某些套接字就绪时，对应比特位即变为1
  5. 另外select托管文件描述符的底层，就是操作系统对文件描述符数组进行遍历，检测关心的事件是否就绪

在理解了select的使用逻辑之后，我们开始对这个服务器进行解读！！！

  1. 在变量设计中我们可以看到我们用了指针数组来维护文件描述符，因为文件描述符是会动态增加的，并且后续需要我们进行select
  2. 外部在使用这个select服务器时，需要先调用InitServer进行初始化，重点是添加监听套接字，和把其他套接字置为空。
  3. 接着就是进行Loop循环来进行服务器的业务（这里我们暂时没有实现业务），在每次循环中我们都设置一个读集合rfds，并且读取当前套接字数组中的所有套接字，并通过系统提供的位操作接口写入导致这个集合中。然后通过select函数监听这些套接字是否就绪（分为两种：listen套接字等待其他套接字就绪，套接字等待数据就绪）
  4. 当我们select成功，表示某些套接字已经就绪，这时我们传入这个集合，因为这个集合在select后，如果某些套接字就绪，则对应比特位被设置为1，那么进入HandlerAccept函数时，如果是监听套接字就绪，那么就相应的进行添加其他套接字进入这个文件描述符数组中。反之即为其他套接字获取到了数据就绪，这时就进行数据的读取！！！
  5. 如此重复3,4的过程，这就完成的select多路转接的服务器 

1.3.select多路转接的优缺点

看到这里大家会直呼牛逼！！！确实是很厉害，我们引入的select之后，对于当前的线程，我们可以一次性的、同时的监听大量的套接字，当某些套接字未就绪时，也不会出现以往单线程阻塞的场景。同理，当进行读写时，也不会进行IO的等待！！！

但是作为第一版的多路转接事件管理器，我们在代码中也能发现，我们需要经常的进行对数组的遍历，这也会造成资源的消耗，虽然select大大地提高的网络通信的效率，但是大量的遍历又降低了效率。 

总而言之：select优点很出众，但同时缺点也无法忽视！！！

select优点：

  • select只需要进行等待，并且可以同时等待大量的文件描述符，再进行IO时，十分高效

select缺点：

  • 每次循环中我们都需要对select的参数进行重置，这部分会存在内存开销
  • select需要不断地遍历管理文件描述符的数据结构，影响了整体服务器的效率
  • 在每次select调用和返回时，内核需要拷贝位图，并对位图进行操作，也就是会不断地进行数据拷贝
  • select在底层实现时，操作系统需要不断地遍历所有托管的文件描述符，检测关心的事件是否就绪，这里也会影响整体效率
  • 位图的大小固定，即select托管的文件描述符的个数具有上限

2.IO多路转接---poll

2.1.接口认识

和select相同，poll也是系统提供的一个事件管理器，用来关系IO过程中的事件等待！！！但是poll的使用和select有较大的不同

​

  •  当我们使用fds这个结构时，需要对这个结构体数组进行内容的初始化，并且这个数组是开辟在堆区，因此我们也可以通过nfds这个参数来托管任意个数的套接字，前提是系统有足够的空间。
  • events、revents是短整型变量，当我们添加参数时，表示关心某个事件，我们通过或|操作符添加，当判断有没有这个事件，我们通过与&操作符判断。
  • 值得一提的是：当我们传入这个rds对象时，我们只需要对event这个内置变量进行操作，revents是由操作系统进行操作的！！！

2.2.poll如何进行多路转接

其他模块的代码从poll多路转接模块- Gitee.com 获取！！！

#include <iostream>
#include <memory>
#include <poll.h>
#include "Log.hpp"
#include "socket.hpp"

const int default_backlog = 5;
class PollServer
{
private:
    void HanderAccept()
    {
        // 可能会处理多个文件描述符
        for (size_t i = 0; i < _num; i++)
        {

            if (_rfds[i].fd == -1)
            {
                continue;
            }
            // 合法的套接字
            else
            {
                // 注意这里会出现：1.Accept新链接  2.read获取到新数据
                int fd = _rfds[i].fd;
                short revents = _rfds[i].revents;

                if (revents & POLLIN)
                {
                    // 表示 获取套接字就绪
                    if (fd == _listen_sock->GetSockFd())
                    {
                        lg.LogMessage(Info, "get a new link\n");
                        std::string client_ip;
                        uint16_t client_port;
                        NetWork::Socket *sock = _listen_sock->AcceptConnection(&client_ip, &client_port);
                        // 获取通信套接字失败
                        if (sock->GetSockFd() == -1)
                        {
                            lg.LogMessage(Error, "sock accept failed\n");
                            continue;
                        }
                        lg.LogMessage(Info, "connect client success, client info is %s:%d, fd = %d\n", client_ip.c_str(), client_port, sock->GetSockFd());

                        // 和select的本质逻辑一致
                        int pos = 0;

                        for (; pos < _num; pos++)
                        {
                            if (_rfds[pos].fd == -1)
                            {
                                _rfds[pos].fd = sock->GetSockFd();
                                _rfds[pos].events |= POLLIN;
                                break;
                            }
                        }
                        if (pos == _num)
                        {
                            // 服务器poll托管套接字已达上限
                            // 1.方式一：允许有上限大小
                            sock->CloseSockFd();
                            delete sock;
                            lg.LogMessage(Warning, "server is full...\n");
                            // 2.方式二：通过扩容实现无上限
                        }
                    }
                    // 表示 读取数据 就绪, 可以在这里进行IO
                    else
                    {
                        char buffer[1024];
                        ssize_t m = recv(fd, buffer, sizeof(buffer) - 1, 0);
                        if (m > 0)
                        {
                            buffer[m] = 0;
                            std::cout << "client message: " << buffer << std::endl;
                        }
                        else if (m == 0)
                        {
                            lg.LogMessage(Info, "data recv ");
                        }
                        else
                        {
                            // 差错处理 client文件描述符关闭 或者是 recv出现错误
                            lg.LogMessage(Error, "recv message failed\n");
                            close(fd);
                            // 取消poll关心事件
                            _rfds[i].fd = -1;
                            _rfds[i].events = 0;
                            _rfds[i].revents = 0;
                        }
                    }
                }
            }
        }
    }

public:
    PollServer(int port) : _port(port), _num(1024), _listen_sock(new NetWork::TcpSocket()), _isrunning(false) {}
    ~PollServer() { delete[] _rfds; }
    void InitServer()
    {
        _listen_sock->BuildListenSocketMethod(_port, default_backlog);

        _rfds = new struct pollfd[_num];
        for (size_t i = 0; i < _num; i++)
        {
            _rfds[i].fd = -1;
            // 将关心的内容设为空
            _rfds[i].events = 0;
            _rfds[i].revents = 0;
        }
        // 初始化时只有listen sock一个文件描述符
        _rfds[0].fd = _listen_sock->GetSockFd();
        // 关心事件events设置为读
        _rfds[0].events |= POLLIN;
    }

    void Loop()
    {
        _isrunning = true;
        while (_isrunning == true)
        {

            int timeout = 1000;
            int n = poll(_rfds, _num, timeout);

            if (n > 0) // poll成功
            {
                lg.LogMessage(Info, "poll success\n");
                // 这里对响应的Accept进行处理
                HanderAccept();
            }
            else if (n == 0) // poll超时
            {
                lg.LogMessage(Info, "poll timeout\n");
            }
            else // poll失败
            {
                lg.LogMessage(Error, "select error\n");
            }
        }
        _isrunning = false;
    }

private:
    std::unique_ptr<NetWork::Socket> _listen_sock;
    int _port;
    bool _isrunning;

    struct pollfd *_rfds;
    int _num;
};

 poll函数的使用逻辑：

  1. 首先对于poll函数而言，也是需要关心套接字就绪和某个套接字的读、写条件就绪的，那么天然的结构就需要和select相似。
  2. 不过因为poll把输入输出型参数分离，而是单纯使用输入性参数，进而不需要每次对参数进行重置，这里是直接通过rfds数组，下标的改变来区分不同的events和revents。
  3. 另外poll和select一致，底层本质上也是对套接字进行遍历访问，检测关心的事件是否就绪，但是poll就绪是系统对struct pollfd这个结构体的revents这个变量进行写入，然后我们在外部进行比较获取是否就绪。

接下来我们来解读一下poll多路转接服务器：

  1. 首先在变量设计中，我们依旧需要管理获取的大量的文件套接字，这时我们构建一个struct pollfd的指针数组来对这些套件字进行后续的访问
  2. 接着我们需要初始化这个指针数组的元素，并且将listen套接字关心的时间设置为读事件，再将其他的套接字设置为空（因为此时只有listen一个套接字）
  3. 接着循环时，我们直接调用poll函数即可，然后进入HanderAccept函数
  4. 如果revents&POLLIN事件成立，表示事件就绪，接着就是分析时套接字就绪还是套接字读取数据就绪，再进行相应的逻辑

  5. 值得一提的是：在套接字就绪的模块中，我们可以实现有上限的管理套接字的指针数组，也可实现动态扩容的管理套接字的数组！

当我们对比select和poll时，我们发现poll明显更加简洁，这时因为poll不需要像select一样每次进入Loop函数中循环对输入输出型参数进行重置，而且struct pollfd这个结构用户能够对关心的事件进行设置，然后由系统查询是否就绪通过revents返回！！！

2.3.poll多路转接优缺点

poll优点：

  • poll可以等待多个文件描述符，能够单线程实现高并发，高效
  • struct pollfd结构体的实现，输入、输出参数分离，不需要频繁对poll的参数进行分离（相比于select）
  • poll关心的文件描述符支持无上限（具体根据操作系统的承载能力）

poll缺点：

  • 还是存在用户和内核之间存在拷贝struct pollfd这些结构体（必要开销）
  • poll函数底层实现还是需要遍历文件描述符，来获取到事件是否就绪

成分不含牛奶
关注
专栏目录
Linux应用编程基础之多路复用：select和poll的简单使用示例
TECH_PRO的博客
09-03 806
一、基本原理 在linux编程基础中，select和poll的I/O多路转接复用模式是处理I/O复用的一个高效的方法。它可以具体设置程序中每一个所关心的文件描述符的条件、希望等待的时间等，从select()和poll()函数返回时，内核会通知用户已准备好的文件描述符的数量、已准备好的条件等。通过使用select()和poll()函数的返回结果，就可以调用相应的I/O 处理函数。在这种模型下，如果
Linux网络编程：多路转接--poll/epoll
qq_52568001的博客
08-25 1087
也是一种多路转接的方案，poll中监听的文件描述符数目增多时 和select函数一样，poll返回后，需要轮询pollfd来获取就绪的描述符. 次调用poll都需要把大量的pollfd结构从用户态拷贝到内核中. 同时连接的大量客户端在一时刻可能只有很少的处于就绪状态, 因此随着监视的描述符数量的增长, 其效率也会线性下降.
【网络编程】多路转接之select、poll、epoll
学了就忘是正常现象
10-18 1013
要想IO效率高，还得是epoll。
计算机网络 | IO多路转接技术 | select详解
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
09-19 1890
IO多路转接技术介绍以及select详解、代码示例。
Linux网络：多路转接
yourfriendyo的博客
09-09 1368
select函数没有读写的功能，只负责IO当中等的环节，一旦条件就绪会通知上层进行读取和写入。read/write,send/recv等IO接口本身也具有等待的功能，不过只能等1个文件条件就绪，select可以同时等多个fd。NAME// fd_set操作函数 void FD_CLR(int fd , fd_set * set);// 清除 int FD_ISSET(int fd , fd_set * set);// 检测 void FD_SET(int fd , fd_set * set);
Linux网络编程：多路I/O转接服务器（select poll epoll）
刘鑫磊
08-23 2306
Linux网络编程：多路I/O转接服务器（select poll epoll）
网络编程: 高级IO与多路转接select,poll,epoll的使用与介绍
Wzs040810的博客
06-07 899
网络编程: 高级IO与多路转接select,poll,epoll的使用与介绍
【Linux网络编程】IO多路转接之poll
fight_p的博客
05-15 633
poll也是一种linux中多路转接的方案。它所对应的多路转接方案主要是解决select两个问题。select的文件描述符有上限的问题，select每次都要重新设置关心的fd*。当我们把接口学习完就知道poll是如何接究select的两个问题。把poll代码写完也会发现poll比select写着更简单一些。但是poll还是有个问题。就是要遍历的问题。这个问题放到epoll中解决。
Linux网络编程之poll多路转接服务器
Selenitic_G的博客
12-25 221
Linux网络编程之poll多路转接服务器
Linux网络编程—— IO多路复用
weixin_43412762的博客
03-03 2580
 I/O 多路复用 使得程序能 同时监听 多个文件描述符，能够提高程序的性能，Linux 下实现 I/O 多路复用 的 系统调用主要有 select、poll 和 epoll。
网络编程4：高并发服务器——多路I/O转接服务器设计（select、poll、epoll）
snaking616
05-04 552
select、poll、epoll三者优缺点对比 1.select /* According to earlier standards */ #include <sys/time.h> #include <sys/types.h> #include <unis...
网络编程（三）TCP IO多路转接服务器编程（select)
weixin_42445051的博客
03-30 3311
一，select知识引入 前面已经介绍过了 1）单线程的服务器，可以处理单个客户端与服务端的交流； 2）多线程的服务器，可以处理多个客户端与服务端的交流。 根据前面的知识，我们知道了如果想要处理多个客户端与服务器的交流的话可以使用多线程的技术，而这篇博客就来介绍一下处理多个客户端与服务器的交流的一个新的技术：IO多路复用——select方法。 二，select基本概念 2.1 select概念理解前先总结一下通信过程（便于后文理解select) 1，listen()监听函数过后，服务器的ip与端口就会暴露在
Linux下I/O多路复用(select、poll、epoll)，含函数解析及注意要点 ，干货满满！！
C__YUE的博客
03-24 1323
liunx下基于c/c++的网络编程中的I/O多路复用（select、poll、epoll）介绍。 select是 Linux 原生的、可跨平台的多路复用技术 poll在 Linux 系统中常被用于高并发网络服务器编程 epoll是一种优于poll的 I/O 多路复用机制，在 Linux 系统中常被用于高并发网络服务器编程；epoll 使用eopll_event 通过epoll_create、epoll_ctl 和 epoll_wait 这三个系统调用来实现事件多路转接。 #多路复用#多路复用#多路复用
UNIX环境高级编程：文件I/O与多路转接
为了克服这个问题，I/O多路转接（通常通过select或poll等系统调用实现）被引入，它允许程序监控多个文件描述符，当任意一个描述符准备好读写时，程序可以非阻塞地进行操作。这种技术在处理并发I/O需求，如网络服务器...
国产服务器平台离线部署k8s和kubesphere(含离线部署新方式)
最新发布
11-02 721
国产服务器平台离线部署k8s和kubesphere(含离线部署新方式)
Linux特种文件系统--tmpfs文件系统
刘元林的博客
10-29 1063
tmpfs类似于RamDisk（只能使用物理内存），使用虚拟内存（简称VM）子系统的页面存储文件。tmpfs完全依赖VM，遵循子系统的整体调度策略。说白了tmpfs跟普通进程差不多，使用的都是某种形式的虚拟内存，至于数据存储在物理内存中还是在交换分区中，全权交由VM子系统。定义： 是一个基于内存的文件系统，它在 RAM 中存储数据，因此访问速度非常快。用途： 通常用于存储临时文件，这些文件不需要永久保存，而且频繁读写。使用 可以减少对物理磁盘的磨损，并提高性能。示例路径：常见的 挂载点包括 、、 等。持
VMware workstation的3种网络类型
但行好事，莫问前程
10-29 560
虚拟机想要和主机进行通信必须借助网桥或者交换机，VMware workstation提供了3种网络交换机：仅主机类型交换机、NAT类型交换机、桥接类型交换机。
服务器文件访问协议
小琳猫的博客
10-29 1271
本篇博客参考网上文档和博客，对基于网络的服务器/主机的文件访问、共享协议进行简要总结，完整内容将会不断更新，以便加深理解和记忆
服务器上清理Docker容器运行日志的正确方法
天涯的浪子
10-30 282
因为是服务器的磁盘空间资源有限，由于docker容器在启动的时候没有限制，导致运行的docker容器随着时间的推移产生的日志越来越多，最后把服务磁盘资源耗尽，服务器的磁盘满了会导致服务器的应用无法正常运行。修改docker daemon.json文件，配置日志文件参数，默认 /etc/docker/daemon.json。docker run 或 dokcer create 时添加参数，如创建并运行。log-opts max-size 容器日志文件上限大小。注意：新创建的容器会生效，原有容器不生效。
Linux网络编程：I/O多路复用与套接字接口详解
"多路复用的基本原理在Linux网络编程中扮演着重要角色，因为它解决了并发处理多路输入输出流的问题。传统的阻塞模式、非阻塞模式和多进程方案都有其局限性。I/O多路复用作为一种有效的解决方案，允许程序等待多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值