高级IO---五种IO模型&多路转接之Select

最新推荐文章于 2024-06-14 13:37:46 发布
最新推荐文章于 2024-06-14 13:37:46 发布
阅读量307 收藏 1
点赞数
分类专栏： 网络 文章标签： 服务器 c++ 网络 计算机网络 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CHJBL/article/details/132746096
版权

文章目录

五种IO模型

1、阻塞IO

在内核将数据准备好之前，系统调用会一直等待。所有的套接字，默认都是阻塞方式。

也就是说，在数据准备好之前，系统调用只会静静的等待着数据的到来并不会去干其他的事情

就好比去钓鱼，将鱼饵丢进水里后，啥也不干就静静的看着鱼饵随时准备鱼上钩

2、非阻塞IO

如果内核还未将数据准备好，系统调用仍然会直接返回，并且返回EWOULDBLOCK错误码。

非阻塞IO往往需要程序员循环的方式反复尝试读写文件描述符，这个过程称为轮询。这对CPU来说是较大的浪费，一般只有特定场景下才使用。

就好比去钓鱼，将鱼饵丢进水里后，不会一直去盯着鱼饵，一边干着其他事看看书啥的偶尔看看鱼饵

3、信号驱动IO

内核将数据准备好的时候，使用SIGIO信号通知应用程序进行IO操作。

这就好比在鱼竿上系上一个铃铛，然后去干别的事，当鱼上钩时拉动鱼线就会使铃铛摇晃发出声音提醒鱼上钩了

4、多路转接IO

最核心在于IO多路转接能够同时等待多个文件描述符的就绪状态。

这就好比拿着多条鱼竿去钓鱼，全部丢进水里然后巡视所有鱼竿，一有鱼上钩就拉动对应的鱼竿

5、异步IO

由内核在数据拷贝完成时, 通知应用程序(而信号驱动是告诉应用程序何时可以开始拷贝数据)。

这就好比老板想吃鱼，不用自己去钓，让手下去钓鱼调到了之后交给他

总结IO

任何IO过程中都包含两个步骤：第一是等待，第二是拷贝。而且在实际的应用场景中，等待消耗的时间往往都远远高于拷贝的时间。所以让IO更高效最核心的办法就是让等待的时间尽量减少

所以综上而言，多把钓竿同时等待，鱼上钩的概率就越大上钩的时间也就越快，所以多路转接IO效率高

同步与异步

同步和异步关注的是消息通信机制

  1. 同步：就是在发出一个调用时，在没有得到结果之前，该调用不返回。但是一旦调用返回，就得到返回值了。换句话说，就是由调用者主动等待这个调用的结果;
  2. 异步：正好相反，调用在发出之后，这个调用就直接返回了，所以没有返回结果; 换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果; 而是在调用发出后，被调用者通过状态、通知来通知调用者，或通过回调函数处理这个调用。

注意这里的同步通信和进程之间的同步是完全不想干的概念

阻塞与非阻塞

  1. 阻塞：调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回
  2. 非阻塞：在不能立刻得到结果之前，该调用不会阻塞当前线程。

设置非阻塞

需要利用系统调用 ---- fcntl

#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* arg */ );

参数一为：需要设置的文件描述符

参数二为：想要让fcntl实现的功能

  1. 复制一个现有的描述符（cmd = F_DUPFD） .
  2. 获得/设置文件描述符标记(cmd = F_GETFD或F_SETFD).
  3. 获得/设置文件状态标记(cmd = F_GETFL或F_SETFL).
  4. 获得/设置异步I/O所有权(cmd = F_GETOWN或F_SETOWN).
  5. 获得/设置记录锁(cmd = F_GETLK,F_SETLK或F_SETLKW)

其中设置非阻塞为第三个功能。

后面的为追加参数

利用fcntl接口实现一个设置非阻塞的函数

void SetNoBlock(int fd) {
	// 使用F_GETFL将当前的文件描述符的属性取出来(这是一个位图)
    int fl = fcntl(fd, F_GETFL);
    
    if (fl < 0) {
        perror("fcntl");
        return;
    }
    // 再使用F_SETFL将文件描述符设置回去. 设置回去的同时, 加上一个O_NONBLOCK参数
    fcntl(fd, F_SETFL, fl | O_NONBLOCK);
}

多路转接之Select

系统提供select函数来实现多路复用输入/输出模型

select系统调用是用来让程序监视多个文件描述符的状态变化的;
程序会停在select这里等待，直到被监视的文件描述符有一个或多个发生了状态改变

select函数原型

 #include <sys/select.h>

/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int select(int nfds, fd_set *readfds, fd_set *writefds,
          fd_set *exceptfds, struct timeval *timeout);
  1. 参数nfds是需要监视的最大的文件描述符值+1
  2. rdset、wrset、exset分别对应于需要检测的可读文件描述符的集合，可写文件描述符的集合及异常文件描述符的集合
  3. 参数timeout为结构timeval，用来设置select()的等待时间，如果在指定的时间段里没有事件发生， select将超时返回

fd_set结构

typedef struct
  {
    /* XPG4.2 requires this member name.  Otherwise avoid the name
       from the global namespace.  */
#ifdef __USE_XOPEN
    __fd_mask fds_bits[__FD_SETSIZE / __NFDBITS];
# define __FDS_BITS(set) ((set)->fds_bits)
#else
    __fd_mask __fds_bits[__FD_SETSIZE / __NFDBITS];
# define __FDS_BITS(set) ((set)->__fds_bits)
#endif
  } fd_set;

其实这个结构就是一个整数数组, 更严格的说，是一个 “位图”. 使用位图中对应的位来表示要监视的文件描述符.

提供了一组操作fd_set的接口, 来比较方便的操作位图

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的全部位

例如取fd_set为1个字节，为1字节， fd_set中的每一bit可以对应一个文件描述符fd。则1字节长的fd_set最大可以对应8个fd

返回值

  1. 执行成功则返回文件描述词状态已改变的个数
  2. 如果返回0代表在描述词状态改变前已超过timeout时间，没有返回
  3. 当有错误发生时则返回-1，错误原因存于errno，此时参数readfds， writefds, exceptfds和timeout的值变成不可预测。

socket就绪条件

读就绪

  1. socket内核中, 接收缓冲区中的字节数, 大于等于低水位标记SO_RCVLOWAT. 此时可以无阻塞的读该文件描述符, 并且返回值大于0;
  2. socket TCP通信中, 对端关闭连接, 此时对该socket读, 则返回0;
  3. 监听的socket上有新的连接请求;
  4. socket上有未处理的错误

写就绪

  1. socket内核中, 发送缓冲区中的可用字节数(发送缓冲区的空闲位置大小), 大于等于低水位标记SO_SNDLOWAT, 此时可以无阻塞的写, 并且返回值大于0;
  2. socket的写操作被关闭(close或者shutdown). 对一个写操作被关闭的socket进行写操作, 会触发SIGPIPE信号;
  3. socket使用非阻塞connect连接成功或失败之后;
  4. socket上有未读取的错误;

select的特点

  1. 可监控的文件描述符个数取决与sizeof(fd_set)的值。每bit表示一个文件描述符
  2. 将fd加入select监控集的同时，还要再使用一个数据结构array保存放到select监控集中的fd，
    1. 一是用于再select 返回后， array作为源数据和fd_set进行FD_ISSET判断。
    2. 二是select返回后会把以前加入的但并无事件发生的fd清空，则每次开始select前都要重新从array取得fd逐一加入(FD_ZERO最先)，扫描array的同时取得fd最大值maxfd，用于select的第一个参数

select的缺点：

  1. 每次调用select, 都需要手动设置fd集合, 从接口使用角度来说也非常不便.
  2. 每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大
  3. 同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大
  4. select支持的文件描述符数量太小

select使用示例

这里以只关心读事件为例，写事件同理

Util.hpp(工具类，将用到的函数放在该类中)

#pragma once

#include <iostream>
#include <unistd.h>
#include <fcntl.h>
#include <string>
#include <sys/socket.h>
#include <functional>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "log.hpp"
#include <cstring>
#include <vector>

using namespace std;

#define INITPORT 8000
#define FDNUM 1024
#define DEFAULTFD -1

// 打印函数调试
void Print(const vector<int> &fdv)
{
    cout << "fd list: ";
    for (int i = 0; i < FDNUM; i++)
    {
        if (fdv[i] != DEFAULTFD)
            cout << fdv[i] << " ";
    }
    cout << endl;
}

class Util
{
public:
    static void Recv(vector<int> &fdv, int sock, int i)
    {
        // 读取
        // 读取失败就关闭sock并且修改集合组里的数据
        char buff[1024];
        ssize_t s = recv(sock, buff, sizeof(buff) - 1, 0);
        if (s > 0)
        {
            buff[s] = 0;
            cout << "client: " << buff << endl;
            LogMessage(NORMAL, "client: %s", buff);
        }
        else if (s == 0)
        {
            close(sock);
            fdv[i] = DEFAULTFD;
            LogMessage(NORMAL, "client quit");
            return;
        }
        else
        {
            close(sock);
            fdv[i] = DEFAULTFD;
            LogMessage(ERROR, "client quit: %s", strerror(errno));
            return;
        }

        // 写回数据
        // 这里不考虑写事件
        string response = buff;

        write(sock, response.c_str(), response.size());
        LogMessage(DEBUG, "Recver end");
    }

    // 将通信sock添加进集合组
    static void AddSock(vector<int> &fdv, int listensock)
    {
        // listensock读事件就绪
        string clientip;
        uint16_t clientport;
        int sock = Util::GetSock(listensock, &clientip, &clientport);
        if (sock < 0)
            return;
        else
        {
            LogMessage(NORMAL, "accept success [%s:%d]", clientip.c_str(), clientport);
            // 遍历数组，要考虑满的情况
            // 遇到为-1的位置插入新的sock
            int i = 0;
            for (; i < FDNUM; ++i)
                if (fdv[i] == DEFAULTFD)
                    break;
            if (i == FDNUM)
            {
                LogMessage(WARNING, "server if full, please wait");
                close(sock);
            }
            else
                fdv[i] = sock;
        }

        Print(fdv);
        LogMessage(DEBUG, "Accepter out");
    }

    // 获取新连接创建通信sock
    static int GetSock(int listensock, string *clientip, uint16_t *clientport)
    {
        struct sockaddr_in peer;
        memset(&peer, 0, sizeof(peer));
        socklen_t len = sizeof(peer);
        int sock = accept(listensock, (struct sockaddr *)&peer, &len);
        if (sock < 0)
            LogMessage(ERROR, "accept socket error, next");
        else
        {
            LogMessage(NORMAL, "accept socket %d success", sock);
            cout << "sock: " << sock << endl;
            *clientip = inet_ntoa(peer.sin_addr);
            *clientport = ntohs(peer.sin_port);
        }

        return sock;
    }

    // 设置监听套接字为监听状态
    static void setListen(int listensock)
    {
        if (listen(listensock, 5) < 0)
        {
            LogMessage(FATAL, "listen socket error!");
            exit(3);
        }
        LogMessage(NORMAL, "listen socket success");
    }

    // 绑定网络信息
    static void bindSock(int port, int listensock)
    {
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = INADDR_ANY;
        if (bind(listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            LogMessage(FATAL, "bind socket error!");
            exit(2);
        }
        LogMessage(NORMAL, "bind sock success");
    }

    // 创建监听套接字
    static void createSock(int *listensock)
    {
        *listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock < 0)
        {
            LogMessage(FATAL, "create socket error!");
            exit(1);
        }
        LogMessage(NORMAL, "create socket success");

        // 设置进程可以立即重启
        int opt = 1;
        setsockopt(*listensock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));
    }

    // 设置非阻塞
    static void SetNonBlock(int fd)
    {
        int f = fcntl(fd, F_GETFL);
        if (f < 0)
        {
            cerr << "fcntl" << endl;
            return;
        }
        fcntl(fd, F_SETFL, f | O_NONBLOCK);
    }
};

Server.hpp(实现服务器)

#pragma once

#include <iostream>
#include "Util.hpp"
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

using namespace std;

class Server
{
public:
    Server(const uint16_t port = INITPORT)
        : _port(port), _listensock(-1)
    {
    }

    void HandlerEvent(fd_set &rfds)
    {
        int i = 0;
        for (auto e : fdv)
        {
            // 过滤掉非法的fd
            if (e == DEFAULTFD)
                continue;
            if (FD_ISSET(e, &rfds) && e == _listensock) // 判断listensock在不在就绪的集合中
                Util::AddSock(fdv, _listensock);
            else if(FD_ISSET(e, &rfds)) // 如果为其他的文件描述符则读取数据
                Util::Recv(fdv, e, i);
            else
            {}

            ++i;
        }
    }

    void Init()
    {
        // 创建监听套接字
        Util::createSock(&_listensock);

        // 绑定网络信息
        Util::bindSock(_port, _listensock);

        // 设置监听套接字为监听状态
        Util::setListen(_listensock);

        fdv.resize(FDNUM, DEFAULTFD);
        fdv[0] = _listensock;
    }

    void start()
    {
        while (1)
        {
            fd_set rfds;
            // 清除描述词组set的全部位
            FD_ZERO(&rfds);
            // 记录下最大的文件描述符
            int max = fdv[0];
            // 遍历数组，将合法的fd插入到事件集中
            // 并记录最大的fd为调用select接口做准备
            for (auto e : fdv)
            {
                if (e == DEFAULTFD)
                    continue;
                // 设置描述词组set中相关fd的位
                FD_SET(e, &rfds);
                if (e > max)
                    max = e;
            }
            // 设置等待时间结构
            struct timeval timeout = {1, 0};
            int n = select(max + 1, &rfds, nullptr, nullptr, &timeout);
            switch (n)
            {
            case 0:
                cout << "timeout...." << endl;
                LogMessage(NORMAL, "timeout....");
                break;
            case -1:
                printf("select error, code: %d, err string: %s", errno, strerror(errno));
                LogMessage(WARNING, "select error, code: %d, err string: %s", errno, strerror(errno));
                break;
            default:
                // 有事件就绪
                cout << "event readly" << endl;
                LogMessage(NORMAL, "event readly");
                // 处理事件
                HandlerEvent(rfds);
                break;
            }
        }
    }

    ~Server()
    {
        if (_listensock < 0)
            close(_listensock);
    }

private:
    int _listensock;
    uint16_t _port;
    vector<int> fdv;
};

log.hpp(日志类)

#pragma once

#include <iostream>
#include <string>
#include <cstdarg>
#include <ctime>
#include <unistd.h>

using namespace std;

#define DEBUG 0
#define NORMAL 1
#define WARNING 2
#define ERROR 3
#define FATAL 4

const char *to_levelstr(int level)
{
    switch (level)
    {
    case DEBUG:
        return "DEBUG";
    case NORMAL:
        return "NORMAL";
    case WARNING:
        return "WARNING";
    case ERROR:
        return "ERROR";
    case FATAL:
        return "FATAL";
    default:
        return nullptr;
    }
}

void LogMessage(int level, const char *format, ...)
{
#define NUM 1024
    char logpre[NUM];
    snprintf(logpre, sizeof(logpre), "[%s][%ld][%d]", to_levelstr(level), (long int)time(nullptr), getpid());

    char line[NUM];
    // 可变参数
    va_list arg;
    va_start(arg, format);

    vsnprintf(line, sizeof(line), format, arg);

    // 保存至文件
    FILE* log = fopen("log.txt", "a");
    FILE* err = fopen("log.error", "a");

    if(log && err)
    {
        FILE *curr = nullptr;
        if(level == DEBUG || level == NORMAL || level == WARNING) 
            curr = log;
        if(level == ERROR || level == FATAL) 
            curr = err;
        if(curr) fprintf(curr, "%s%s\n", logpre, line);

        fclose(log);
        fclose(err);
    }
}

Server.cc

#include "Server.hpp"
#include <memory>

// 输出命令错误函数
void Usage(string proc)
{
    cout << "Usage:\n\t" << proc << " local_port\n\n";
}

int main(int argc, char *argv[])
{
    // 启动服务端不需要指定IP
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(1);
    }

    uint16_t port = atoi(argv[1]);
    unique_ptr<Server> sptr(new Server(port));

    sptr->Init();
    sptr->start();

    return 0;
}

效果演示

image-20230907205551697

首先由客户端连接，listen套接字就绪，建立连接

然后客户端发送数据，负责通信的套接字就绪，读取数据后再发回去

CHJBL
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【高级IO】- 五种 IO 模型 | 多路转接 - select
qq_63938813的博客
08-19 676
五种IO模型 && 多路转接之 select
由浅入深理解高级IO--select poll epoll
qq_49613557的博客
02-10 1071
由浅入深理解高级IO–select poll epoll 目录五种IO模型阻塞IO二级目录三级目录 五种IO模型 阻塞IO 在内核将数据准备好之前, 系统调用会一直等待. 所有的套接字, 默认都是阻塞方式 二级目录 三级目录 ...
五种IO模型以及select多路转接IO模型
flyingcloud6的博客
02-24 772
高并发的基础：多路转接。 对selectIO模型进行了详细的总结。
高级IO：五种高阶IO模型、多路转接(select、poll、epoll)
HanMeng的博客
08-16 818
文章目录：前言1.五种高阶IO模型1.1 阻塞IO1.2 非阻塞IO1.3 信号驱动IO1.4 多路转接IO(可监控多个文件描述符)1.5 异步IO2.多路转接技术(select、poll、epoll)2.1 select2.1.1 函数原型及参数解释2.1.2 fd_set解释2.1.3 返回值2.2 selset代码验证2.2.1 select简单验证 前言 任何IO操作都需要经过 等待 和 拷贝数据 这两个过程，而这两个过程是在内核当中的过程 1.五种高阶IO模型 1.1 阻塞IO 在内核将数据准
开发工具 commons-io-1.3.2
05-31
开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2开发工具 commons-io-1.3.2...
IO-LINK V1.1.2 和V1.1.3相关标准-中文和英文
09-26
里面有22个文件，2个中文的
IO-Link 全局库文件（ MASTER 和 DEVICE）FB50001及说明.zip
08-16
IO-Link 全局库文件（ MASTER 和 DEVICE）FB50001及说明
commons-io-2.2-API文档-中英对照版.zip
04-07
赠送jar包：commons-io-2.2.jar 赠送原API文档：commons-io-2.2-javadoc.jar 赠送源代码：commons-io-2.2-sources.jar 包含翻译后的API文档：commons-io-2.2-javadoc-API文档-中文(简体)-英语-对照版.zip 对应...
IO-Link IOL-Interface-Spec_10002_V113_Jun19.pdf
07-28
IO-Link协议规范，V1.1.3最新标准；IO-Link Interface and System Specification V1.1.3; IO-Link 技术是 IEC 61131-9标准的一部分，本文档即此标准的第9部分; 可依据此规范编写IO-link协议栈代码； This part of ...
nc网络收发测试-tcp客户端\TCP服务器\UDP\UDP广播
06-14 299
nc网络收发测试-tcp客户端
百度网盘限速解决办法
生活在别处
06-13 3588
比如可以获取下载直链后，使用IDM（Internet Download Manager）对该直链进行多线程下载，但是并不会有实际速率提升效果，因为百度网盘在服务器端进行了限速，多线程的速率总和被限制在了100KB/s左右。（现在虽然是所谓玩游戏获得会员下载体验，实际上点击后会在百度网盘内打开一个web游戏，并不需要游玩游戏，直接等待会员下载体验时间结束即可关闭web游戏窗口）所以，客户端这些改动伎俩通通没有实际效果，即使在客户端显示无限速、显示会员体验，都只是自欺欺人而已。
ASP 应用程序
csbysj2020的博客
06-09 385
ASP（Active Server Pages）是一种由微软开发的服务器端脚本环境，用于动态网页的创建。ASP允许开发者使用多种脚本语言，如VBScript或JScript，来创建交互式的网页。这些网页可以与数据库交互，处理表单数据，以及执行其他服务器端任务。ASP应用程序通常运行在Windows服务器上，并需要IIS（Internet Information Services）作为其Web服务器。
多进程并发服务器
dc爱傲雪和技术
06-12 263
3.子进程：完成通信，接受一个客户端连接，就创建一个子进程用于通信。要实现TCP通信服务器处理并发的任务，使用多线程或者多进程来解决。2.父进程负责等待并接受客户端的连接。
计算机网络(6) ICMP协议
最新发布
qq_42761215的博客
06-14 402
ICMP是网络通信中不可或缺的协议，虽然不传输用户数据，但在网络管理和诊断中起着重要作用。理解ICMP及其各种消息类型对于网络管理员和工程师来说是至关重要的，它有助于维护网络的正常运行和性能优化。
Linux C语言：函数的基本用法及传参
Liu1013216383的博客
06-12 808
在程序运行过程中，将实际参数的值或者地址传递给被调用函数的形式参数，从而在函数中完成对数据处理和返回的过程。在C语言当中，参数的传递方式本质上只有一种，就是值传递。但为了更好区分理解，划分了三种方式。
Linux 常用命令 - userdel 【删除用户】
随便转转
06-12 122
userdel 这个命令源自于 “user delete”，即用户删除。这个命令主要用于在 Linux 系统中删除用户账户及其相关文件。当管理员需要移除一个用户及其在系统中的所有踪迹时，会用到这个命令。
服务器被墙是什么原因，怎么解决服务器被墙
m0_70754056的博客
06-11 256
安全问题：服务器被发现存在漏洞或存在安全隐患时，为了保护网络安全，防止黑客入侵或恶意攻击，管理员可能会采取封锁措施。提高网络安全性：及时更新服务器、操作系统和应用程序的补丁，加强网络安全防护措施，减少服务器被黑客攻击的风险。更改DNS服务器：将DNS服务器更改为可用的公共DNS服务器，以避免被封锁的网站或应用程序。最重要的是了解服务器被墙的原因以及采取有效的措施应对，确保服务器的正常运行和数据安全。寻找替代网络服务：如果服务器被封锁，可以寻找其他类似的服务或平台，以满足需要。
C#完整服务器
weixin_73535261的博客
06-11 341
启动服务器后可以使用《tcp客户端》连接服务器。
perl-IO-Socket-IP
06-12
perl-IO-Socket-IP 是一个 Perl 语言的软件包，它提供了一种用于创建基于 IP 协议的网络套接字的工具。使用 perl-IO-Socket-IP 可以方便地创建并管理 IP 协议的网络套接字，以便于实现网络通信和数据传输。 perl-IO-Socket-IP 提供了一组用于网络套接字管理的函数和接口，以便于 Perl 程序更加方便地实现网络套接字的创建和管理。perl-IO-Socket-IP 支持多种不同的 IP 协议网络套接字管理操作，例如创建 TCP 套接字、创建 UDP 套接字等等，开发者可以根据实际的需求选择不同的网络套接字管理操作来实现数据传输。 使用 perl-IO-Socket-IP 可以帮助开发者更加高效地实现网络通信和数据传输，以便于实现一些需要网络通信和数据传输的复杂任务。需要注意的是，perl-IO-Socket-IP 的使用需要一定的 Perl 编程经验和技能，同时还需要对 IP 协议和网络通信的相关知识有一定的了解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CHJBL

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值