Linux编程：基于 Unix Domain Socket 的进程/线程间通信实时性优化

news2024/11/14 13:04:08

文章目录

    • 0. 引言
    • 1. 使用 `epoll` 边缘触发模式
      • 非不要不选择阻塞模式
      • 边缘触发（ET）模式
      • 优点
      • 示例
    • 2. 使用实时调度策略
    • 3. CPU 绑定
    • 4. 使用无锁缓冲区
    • 5. 优化消息传递的大小和频率
    • 6. 使用 `SO_RCVTIMEO` 和 `SO_SNDTIMEO`
    • 7. 示例代码
    • 其他阅读

0. 引言

前几天被问到“如何优化Linux中Domain Socket的线程间通信实时性？”当时的回答感觉不够好，经过仔细思考后，我整理出以下优化策略，考虑的是高并发和低延迟场景中的应用优化。

1. 使用 epoll 边缘触发模式

非不要不选择阻塞模式

阻塞式 read() 在单客户端的情况下，能够立即响应数据的到达，但其局限性在于：

  • 无法同时处理多个 I/O 操作。如果同时需要接收和发送数据，阻塞式 read() 会在读取数据时阻塞当前线程，直到数据可用，这使得线程无法在等待数据时执行其他任务（例如发送数据）。 也就是处理双向通信不够高效。
  • 阻塞导致线程空闲。即使线程处于阻塞状态，系统仍需要为其调度，但线程无法做任何实际工作。这样会浪费 CPU 时间，降低系统的响应性和资源利用率。

边缘触发（ET）模式

epoll 的 边缘触发 模式（ET）在文件描述符的状态发生变化时仅触发一次事件。当状态从“不可读”变为“可读”时，epoll 只会通知一次，后续不会触发事件直到状态再次变化。这减少了重复触发事件的系统调用，降低了上下文切换的频率。

优点

  • 减少系统调用和上下文切换：边缘触发模式比水平触发模式（LT）减少了不必要的系统调用。
  • 更低延迟：每个事件只触发一次，避免了多次触发导致的等待时间。
  • 更高效率：配合非阻塞 I/O 使用，避免了重复的事件通知。

示例

struct epoll_event ev;
ev.events = EPOLLIN | EPOLLET;  // 设置为边缘触发模式
ev.data.fd = sockfd;
if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &ev) == -1) {
    perror("epoll_ctl");
    exit(EXIT_FAILURE);
}

2. 使用实时调度策略

Linux 提供了 SCHED_FIFO 和 SCHED_RR 等实时调度策略，可以降低调度延迟。通过 sched_setscheduler() 函数设置线程调度策略，有助于提升线程的响应速度。

struct sched_param param;
param.sched_priority = 99;  // 设置较高的优先级
sched_setscheduler(pid, SCHED_FIFO, &param);  // 设置实时调度策略

3. CPU 绑定

将线程绑定到特定的 CPU 核，减少跨核调度和缓存失效，降低延迟。

cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(cpu_id, &cpuset);  // 将线程绑定到指定的 CPU 核
pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);

4. 使用无锁缓冲区

使用无锁缓冲区可以减少CPU时间片切换次数：

  • 无锁队列：使用原子操作管理数据结构，避免传统锁机制的性能瓶颈，减少线程同步的开销。

实现请见：C++生产者-消费者无锁缓冲区的简单实现

5. 优化消息传递的大小和频率

每次发送或接收的数据大小直接影响通信延迟。频繁的小数据传输会增加 I/O 操作次数，导致延迟增加。优化措施包括：

  • 批量传输：将多个小消息合并为一个大消息，减少系统调用次数和上下文切换频率。
  • 调整缓冲区大小：根据应用需求调整套接字的发送和接收缓冲区大小，以避免缓冲区过小导致频繁的上下文切换。
int bufsize = 8192;  // 请根据实际设置合适的缓冲区大小
setsockopt(socket_fd, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
setsockopt(socket_fd, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));

6. 使用 SO_RCVTIMEO 和 SO_SNDTIMEO

SO_RCVTIMEO 和 SO_SNDTIMEO 是用来防止套接字在接收或发送数据时无限期阻塞的选项。当设置了这些超时选项后，套接字在等待数据时会在超时后返回错误（如 EAGAIN 或 EWOULDBLOCK），从而提高应用程序的响应性。然而，这些选项不能直接解决由于 CPU 调度延迟引起的实时性问题。它们的作用仅仅是在指定时间内没有完成操作时返回错误，而不是保证操作在一定时间内完成。

// 设置接收超时时间
struct timeval recv_timeout = { 1, 0 }; // 1 seconds
if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &recv_timeout, sizeof(recv_timeout)) == -1) {
    perror("setsockopt SO_RCVTIMEO");
    close(sock);
    exit(EXIT_FAILURE);
}

// 设置发送超时时间
struct timeval send_timeout = { 1, 0 }; // 1 seconds
if (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &send_timeout, sizeof(send_timeout)) == -1) {
    perror("setsockopt SO_SNDTIMEO");
    close(sock);
    exit(EXIT_FAILURE);
}

7. 示例代码

// g++ -o uds_server uds_server.cpp -pthread
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/un.h>
#include <cstring>
#include <cerrno>
#include <atomic>
#include <pthread.h>
#include <sched.h>

#define SOCKET_PATH "/tmp/uds_socket"
#define MAX_EVENTS 10
#define BUF_SIZE 1024
#define SOCKET_BACKLOG 5

// 无锁环形缓冲区
class LockFreeBytesBuffer {
public:
    static const std::size_t kBufferSize = 10240U;  // 缓冲区大小

    LockFreeBytesBuffer() noexcept : readerIndex_(0U), writerIndex_(0U) {
        std::memset(buffer_, 0, kBufferSize);
    }

    bool append(const char* data, std::size_t length) noexcept;
    std::size_t beginRead(const char** target) noexcept;
    void endRead(std::size_t length) noexcept;

private:
    char buffer_[kBufferSize];
    std::atomic<std::size_t> readerIndex_;
    std::atomic<std::size_t> writerIndex_;
};

bool LockFreeBytesBuffer::append(const char* data, std::size_t length) noexcept {
    const std::size_t currentWriteIndex = writerIndex_.load(std::memory_order_relaxed);
    const std::size_t currentReadIndex = readerIndex_.load(std::memory_order_acquire);

    const std::size_t freeSpace = (currentReadIndex + kBufferSize - currentWriteIndex - 1U) % kBufferSize;
    if (length > freeSpace) {
        return false;  // 缓冲区满
    }

    const std::size_t pos = currentWriteIndex % kBufferSize;
    const std::size_t firstPart = std::min(length, kBufferSize - pos);
    std::memcpy(&buffer_[pos], data, firstPart);
    std::memcpy(&buffer_[0], data + firstPart, length - firstPart);

    writerIndex_.store(currentWriteIndex + length, std::memory_order_release);
    return true;
}

std::size_t LockFreeBytesBuffer::beginRead(const char** target) noexcept {
    const std::size_t currentReadIndex = readerIndex_.load(std::memory_order_relaxed);
    const std::size_t currentWriteIndex = writerIndex_.load(std::memory_order_acquire);

    const std::size_t availableData = (currentWriteIndex - currentReadIndex) % kBufferSize;
    if (availableData == 0U) {
        return 0U;  // 缓冲区空
    }

    const std::size_t pos = currentReadIndex % kBufferSize;
    *target = &buffer_[pos];
    return std::min(availableData, kBufferSize - pos);
}

void LockFreeBytesBuffer::endRead(std::size_t length) noexcept {
    const std::size_t currentReadIndex = readerIndex_.load(std::memory_order_relaxed);
    readerIndex_.store(currentReadIndex + length, std::memory_order_release);
}

// 设置套接字为非阻塞
int setSocketNonBlocking(int sockfd) {
    int flags = fcntl(sockfd, F_GETFL, 0);
    if (flags == -1) {
        fprintf(stderr, "Error getting socket flags: %s\n", strerror(errno));
        return -1;
    }

    if (fcntl(sockfd, F_SETFL, flags | O_NONBLOCK) == -1) {
        fprintf(stderr, "Error setting socket to non-blocking: %s\n", strerror(errno));
        return -1;
    }

    return 0;
}

// 设置实时调度策略
void setRealTimeScheduling() {
    struct sched_param param;
    param.sched_priority = 99;  // 设置较高的优先级
    if (sched_setscheduler(0, SCHED_FIFO, &param) == -1) {
        fprintf(stderr, "Error setting real-time scheduler: %s\n", strerror(errno));
        exit(EXIT_FAILURE);
    }
}

// 绑定线程到指定 CPU
void setThreadAffinity(int cpuId) {
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(cpuId, &cpuset);
    if (pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset) != 0) {
        fprintf(stderr, "Error setting thread affinity: %s\n", strerror(errno));
        exit(EXIT_FAILURE);
    }
}

// 处理新连接
void handleNewConnection(int epollFd, int sockfd) {
    struct epoll_event ev;
    int connfd = accept(sockfd, nullptr, nullptr);
    if (connfd == -1) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            return;
        }
        fprintf(stderr, "Error accepting connection: %s\n", strerror(errno));
        return;
    }

    if (setSocketNonBlocking(connfd) == -1) {
        close(connfd);
        return;
    }

    ev.events = EPOLLIN | EPOLLET;  // 设置为边缘触发模式
    ev.data.fd = connfd;
    if (epoll_ctl(epollFd, EPOLL_CTL_ADD, connfd, &ev) == -1) {
        fprintf(stderr, "Error adding connection to epoll: %s\n", strerror(errno));
        close(connfd);
    }
}

// 处理读取数据
void handleRead(int epollFd, struct epoll_event& event, LockFreeBytesBuffer& buffer) {
    char buf[BUF_SIZE];
    ssize_t nread = read(event.data.fd, buf, sizeof(buf));
    if (nread == -1) {
        if (errno != EAGAIN) {
            fprintf(stderr, "Error reading data: %s\n", strerror(errno));
            epoll_ctl(epollFd, EPOLL_CTL_DEL, event.data.fd, nullptr);
            close(event.data.fd);
        }
    } else if (nread == 0) {
        epoll_ctl(epollFd, EPOLL_CTL_DEL, event.data.fd, nullptr);
        close(event.data.fd);  // 连接关闭
    } else {
        fprintf(stdout, "Received data: %.*s\n", static_cast<int>(nread), buf);
        if (!buffer.append(buf, nread)) {
            fprintf(stderr, "Error appending to buffer: Buffer overflow!\n");
        }
    }
}

// 处理写操作
void handleWrite(int epollFd, struct epoll_event& event, LockFreeBytesBuffer& buffer) {
    const char* data;
    std::size_t len = buffer.beginRead(&data);
    if (len > 0) {
        ssize_t nwrite = write(event.data.fd, data, len);
        if (nwrite == -1) {
            if (errno != EAGAIN) {
                fprintf(stderr, "Error writing data: %s\n", strerror(errno));
                epoll_ctl(epollFd, EPOLL_CTL_DEL, event.data.fd, nullptr);
                close(event.data.fd);
            }
        } else {
            buffer.endRead(nwrite);
        }
    }
}

// 主函数
int main() {
    int sockfd, epollFd;
    struct sockaddr_un addr;
    struct epoll_event ev, events[MAX_EVENTS];

    // 设置实时调度
    setRealTimeScheduling();
    // 设置线程亲和性
    setThreadAffinity(0);  // 绑定到 CPU 0

    // 创建 Unix Domain Socket
    sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sockfd == -1) {
        fprintf(stderr, "Error creating socket: %s\n", strerror(errno));
        return EXIT_FAILURE;
    }

    // 设置套接字为非阻塞
    if (setSocketNonBlocking(sockfd) == -1) {
        close(sockfd);
        return EXIT_FAILURE;
    }

    // 绑定套接字到文件路径
    std::memset(&addr, 0, sizeof(struct sockaddr_un));
    addr.sun_family = AF_UNIX;
    std::strcpy(addr.sun_path, SOCKET_PATH);
    unlink(SOCKET_PATH);

    if (bind(sockfd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)) == -1) {
        fprintf(stderr, "Error binding socket: %s\n", strerror(errno));
        close(sockfd);
        return EXIT_FAILURE;
    }

    // 监听连接请求
    if (listen(sockfd, SOCKET_BACKLOG) == -1) {
        fprintf(stderr, "Error listening on socket: %s\n", strerror(errno));
        close(sockfd);
        return EXIT_FAILURE;
    }

    // 创建 epoll 实例
    epollFd = epoll_create1(0);
    if (epollFd == -1) {
        fprintf(stderr, "Error creating epoll instance: %s\n", strerror(errno));
        close(sockfd);
        return EXIT_FAILURE;
    }

    // 将服务器套接字加入 epoll
    ev.events = EPOLLIN | EPOLLET;  // 边缘触发模式
    ev.data.fd = sockfd;
    if (epoll_ctl(epollFd, EPOLL_CTL_ADD, sockfd, &ev) == -1) {
        fprintf(stderr, "Error adding socket to epoll: %s\n", strerror(errno));
        close(sockfd);
        close(epollFd);
        return EXIT_FAILURE;
    }

    LockFreeBytesBuffer buffer;

    // 主循环，等待并处理事件
    while (true) {
        int n = epoll_wait(epollFd, events, MAX_EVENTS, -1);
        if (n == -1) {
            fprintf(stderr, "Error in epoll_wait: %s\n", strerror(errno));
            break;
        }

        for (int i = 0; i < n; i++) {
            if (events[i].data.fd == sockfd) {
                // 处理新连接
                handleNewConnection(epollFd, sockfd);
            } else if (events[i].events & EPOLLIN) {
                // 处理读取数据
                handleRead(epollFd, events[i], buffer);
            } else if (events[i].events & EPOLLOUT) {
                // 处理写操作
                handleWrite(epollFd, events[i], buffer);
            }
        }
    }

    close(epollFd);
    close(sockfd);
    return EXIT_SUCCESS;
}

这个程序监听 Unix 域套接字 /tmp/uds_socket，能够处理多个客户端的连接，并异步地读取和写入数据：

  • 监听和接受连接：服务器首先通过 bind 和 listen 绑定套接字，然后通过 accept 等待来自客户端的连接。
  • 异步 I/O 事件处理：使用 epoll 来监听并处理事件（如接收数据、发送数据、错误等）。
  • epoll边缘触发：通过设置非阻塞 I/O 和边缘触发模式，程序能够高效地处理大量并发连接。
  • 缓冲区管理：使用环形缓冲区管理接收的数据。

其他阅读

  • 非Domain Socket的优化请参考：Linux编程：嵌入式ARM平台Linux网络实时性能优化
  • Linux 编程：高实时性场景下的内核线程调度与网络包发送优化
  • Linux I/O编程：I/O多路复用与异步 I/O对比

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2240186.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

element-ui-plus给头像avatar增加头像框

element-ui-plus给头像avatar增加头像框

template部分&#xff1a; <el-avatar shape"square" :size"50" :fit"fit":src"avatarImg"class"avatar-with-border-image"/>style部分&#xff1a; .avatar-with-border-image {position: relative;margin-top: 5px…
阅读更多...
MySQL 忘记 root 密码，使用跳过密码验证进行登录

MySQL 忘记 root 密码，使用跳过密码验证进行登录

操作系统版本&#xff1a;CentOS 7 MySQL 忘记 root 密码&#xff0c;使用跳过密码验证进行登录 修改 /etc/my.cnf 配置文件&#xff0c;在 [mysqld] 后面任意一行添加 skip-grant-tables vim /etc/my.cnf 重启 MySQL systemctl restart mysqld 登录 MySQL&#xff08;无 -…
阅读更多...
飞书 富文本（Markdown）

飞书 富文本（Markdown）

飞书机器人webhook支持Markdown格式&#xff0c;包括表格 表格 |Syntax | Description |\n|-------- | -------- |\n|Header | Title |\n|Paragraph | Text |参考 富文本&#xff08;Markdown&#xff09;
阅读更多...
jmeter常用配置元件介绍总结之用linux服务器压测

jmeter常用配置元件介绍总结之用linux服务器压测

系列文章目录 安装jmeter jmeter常用配置元件介绍总结之用linux服务器压测 1.编写测试脚本2.执行测试脚本 1.编写测试脚本 在linux服务器上进行压测&#xff0c;由于是没有界面的&#xff0c;因此我们可以先在界面上把压测脚本写好&#xff1a; 如图&#xff1a;我这里简单的写…
阅读更多...
记录日志中logback和log4j2不能共存的问题

记录日志中logback和log4j2不能共存的问题

本文章记录设置两个日志时候&#xff0c;控制台直接报错 标黄处就是错误原因&#xff1a;1. SLF4J(W)&#xff1a;类路径包含多个SLF4J提供程序。 SLF4J(W)&#xff1a;找到提供程序[org.apache.logging.slf4j. net]。 SLF4J(W)&#xff1a;找到提供程序[ch.qos.log .classi…
阅读更多...
丹摩征文活动 |通过Pycharm复现命名实体识别模型--MECT模型

丹摩征文活动 |通过Pycharm复现命名实体识别模型--MECT模型

文章目录 &#x1f34b;1 引言&#x1f34b;2 平台优势&#x1f34b;3 丹摩平台服务器配置教程&#x1f34b;4 实操案例&#xff08; MECT4CNER-main&#xff09;&#x1f34b;4.1 MECT4CNER-main模型&#x1f34b;4.2 环境配置&#x1f34b;4.3 训练模型&#x1f34b;4.4 数据…
阅读更多...
电脑浏览器打不开网页怎么办 浏览器无法访问网页解决方法

电脑浏览器打不开网页怎么办 浏览器无法访问网页解决方法

我们在使用电脑的时候&#xff0c;使用浏览器是经常的&#xff0c;很多用户在点开浏览器时&#xff0c;却遇到浏览器无法访问网页的情况。那么电脑浏览器打不开网页是什么原因呢&#xff1f;今天小编就给大家分享几个常见的原因和具体的解决方法&#xff0c;希望能对大家有所帮…
阅读更多...
YOLOv11实战宠物狗分类

YOLOv11实战宠物狗分类

本文采用YOLOv11作为核心算法框架&#xff0c;结合PyQt5构建用户界面&#xff0c;使用Python3进行开发。YOLOv11以其高效的特征提取能力&#xff0c;在多个图像分类任务中展现出卓越性能。本研究针对5种宠物狗数据集进行训练和优化&#xff0c;该数据集包含丰富的宠物狗图像样本…
阅读更多...
Struts源码阅读——三个常用的辅助类DispatchAction

Struts源码阅读——三个常用的辅助类DispatchAction

Struts源码阅读——三个常用的辅助类 紧接前文&#xff0c;我们来阅读org.apache.struts.actions包中三个常用类的源码。 DispatchAction、LookupDispatchAction 和 MappingDispatchAction 是 Struts 1 框架中的三个常用的辅助类&#xff0c;用来简化 Action 类中的请求分发。…
阅读更多...
Linux设置Nginx开机启动

Linux设置Nginx开机启动

操作系统环境&#xff1a;CentOS 7 【需要 root 权限&#xff0c;使用 root 用户进行操作】 原理&#xff1a;利用 systemctl 管理服务 设置 Nginx 开机启动 需要 root 权限&#xff0c;普通用户使用 sudo 进行命令操作 原理&#xff1a;利用 systemctl 管理服务 1、新建…
阅读更多...
C# WPF 记录DataGrid的表头顺序，下次打开界面时应用到表格中

C# WPF 记录DataGrid的表头顺序，下次打开界面时应用到表格中

效果&#xff1a; 代码实现 前端 <DataGrid x:Name"DataGrid1"<!--定义当列位置变化后的触发事件-->CanUserReorderColumns"True"ColumnReordered"DataGrid_ColumnReordered"rubyer:ControlHelper.FocusedForegroundBrush"{Stati…
阅读更多...
Transformer-BiLSTM、Transformer、CNN-BiLSTM、BiLSTM、CNN五模型多变量回归预测

Transformer-BiLSTM、Transformer、CNN-BiLSTM、BiLSTM、CNN五模型多变量回归预测

Transformer-BiLSTM、Transformer、CNN-BiLSTM、BiLSTM、CNN五模型多变量回归预测 目录 Transformer-BiLSTM、Transformer、CNN-BiLSTM、BiLSTM、CNN五模型多变量回归预测预测效果基本介绍程序设计参考资料 预测效果 基本介绍 吐血售&#xff01;聚划算&#xff01;Transforme…
阅读更多...
面试官：如何设计一个能够支持高并发的系统？

面试官：如何设计一个能够支持高并发的系统？

强烈推荐 前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站:人工智能 设计一个支持高并发的系统是一个系统工程&#xff0c;涉及多个层面的优化。以下逐一展开说明&#xff1a; 1. 分布式架…
阅读更多...
企业数字化转型指南：如何通过价值流推动业务创新与变革

企业数字化转型指南：如何通过价值流推动业务创新与变革

在全球企业加速数字化转型的浪潮中&#xff0c;企业领导者和技术人员必须理解数字化转型的核心不只是技术的应用&#xff0c;而是业务流程的彻底重塑。根据《价值流&#xff08;Value Streams&#xff09;》中的理论框架&#xff0c;数字化转型的关键在于价值流&#xff08;Val…
阅读更多...
知识库管理系统：企业数字化转型的加速器

知识库管理系统：企业数字化转型的加速器

在数字化转型的大潮中&#xff0c;知识库管理系统&#xff08;KBMS&#xff09;已成为企业提升效率和创新能力的关键工具。本文将探讨知识库管理系统的定义、企业建立知识库的必要性&#xff0c;以及如何快速搭建企业知识库。 知识库管理系统是什么&#xff1f; 知识库管理系统…
阅读更多...
Python 绘图工具详解：使用 Matplotlib、Seaborn 和 Pyecharts 绘制散点图

Python 绘图工具详解：使用 Matplotlib、Seaborn 和 Pyecharts 绘制散点图

目录 数据可视化1.使用 matplotlib 库matplotlib 库 2 .使用 seaborn 库seaborn 库 3 .使用 pyecharts库pyecharts库 注意1. 确保安装了所有必要的库2. 检查Jupyter Notebook的版本3. 使用render()方法保存为HTML文件4. 使用IFrame在Notebook中显示HTML文件5. 检查是否有其他输…
阅读更多...
JAVA学习日记（十五） 数据结构

JAVA学习日记（十五） 数据结构

一、数据结构概述 数据结构是计算机底层存储、组织数据的方式。 数据结构是指数据相互之间以什么方式排列在一起的。 数据结构是为了更加方便的管理和使用数据&#xff0c;需要结合具体的业务场景来进行选择。 二、常见的数据结构 &#xff08;一&#xff09;栈 特点&…
阅读更多...
【C++】—掌握STL vector 类：“Vector简介：动态数组的高效应用”

【C++】—掌握STL vector 类：“Vector简介：动态数组的高效应用”

文章目录 1.vector的介绍和使用1.1vector的介绍1.2 vector的特点1.3vector的使用1.3.1vector的定义1.3.2vector iterator的使用1.3.3vector 的空间增长问题1.3.4 vector 的增删查改1.3.5vector 迭代器失效问题 1.vector的介绍和使用 1.1vector的介绍 vector是一个顺序容器&am…
阅读更多...
PTE-中间件安全

PTE-中间件安全

DOCKER环境&#xff0c;一般是80 8080 8081端口 1 apache位置扩展名解析漏洞 cd vulhub-master/httpd/apache_parsing_vulnerability/ docker-compose up -d 修改一句话的后缀 直接上传 蚁剑 2 CVE-2017-15715 docker-compose stop cd .. cd CVE-2017-15715/ dock…
阅读更多...
Python用CEEMDAN-LSTM-VMD金融股价数据预测及SVR、AR、HAR对比可视化

Python用CEEMDAN-LSTM-VMD金融股价数据预测及SVR、AR、HAR对比可视化

全文链接&#xff1a;https://tecdat.cn/?p38224 分析师&#xff1a;Duqiao Han 股票市场是一个复杂的非线性系统&#xff0c;股价受到许多经济和社会因素的影响。因此&#xff0c;传统的线性或近线性预测模型很难有效、准确地预测股票指数的价格趋势。众所周知&#xff0c;深…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023