Unix网络编程-Posix消息队列

最新推荐文章于 2025-02-14 12:30:28 发布
最新推荐文章于 2025-02-14 12:30:28 发布
阅读量561 收藏 4
点赞数 1
分类专栏： Unix网络编程 文章标签： unix 网络 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/nine_world/article/details/124533848
版权

消息队列的创建

  1. 命名只能是/queuename.
  2. 默认存放在/dev/mqueue里，（posixIPC都在这里，System V 可以用ipcs查看）
  3. 与内核相同的持续时间——除非删除队列，否则里面的消息不丢失
  4. 存在引用计数，最后一个计数为0且unlink可以删除

创建：

/**
 * @file 1-mqcreate.c
 * 创建一个消息队列
 */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <mqueue.h>
// 注意Posxi消息队列的命名只能是/queuename.
// 不可以用路径，默认都是放在/dev/mqueue里
#define MQNAME "/temp.1234"
// 创建的文件的权限
#define MODE (S_IRWXU | S_IRWXG | S_IRWXO)
int main(int argc, char **argv)
{
    mqd_t mqd;
    mqd = mq_open(MQNAME, O_RDWR | O_CREAT, MODE, NULL);
    if (mqd == (mqd_t)-1)
    {
        perror("mq_open");
        exit(-1);
    }
    mq_close(mqd);
    // 不加这句，temp.1234 不会被删除，这了这句话，就会被删除
    // mq_unlink(MQNAME);
    exit(0);
}

设置和获取队列属性

设置属性：

/**
 * @file 2-mqsetattr.c
 * 设置或修改消息队列的属性
 * 属性有四项：flag, maxmsg, msgsize, curmsgs;
 * 其中：
 * 1.消息队列的最大容量和每个消息的最大长度只能在创建的时候设置,手动检查是否为0,不能超过规定值（文件中）
 * 2.flag只有是否阻塞两个选项，可以随意随时设置
 * 3.当前消息队列的消息的个数，任何时候不能设置，只能获取
 */
#include <fcntl.h>
#include <sys/stat.h>
#include <mqueue.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MQNAME "/temp.1"
#define MODE (S_IRWXU | S_IRWXG | S_IRWXO)
int main(int argc, char **agrv)
{
    if (argc < 2)
    {
        fprintf(stderr, "Using...\n");
        exit(0);
    }
    mqd_t mqd;
    struct mq_attr attr;
    memset(&attr, 0, sizeof(attr));
    attr.mq_maxmsg = atol(agrv[1]);
    attr.mq_msgsize = atol(agrv[2]);
    mqd = mq_open(MQNAME, O_RDWR | O_CREAT | O_EXCL, MODE, &attr);
    if (mqd == (mqd_t)-1)
    {
        perror("mq_open");
        exit(-1);
    }
    mq_close(mqd);
    exit(0);
}

获取属性：

/**
 * @file 2-mqgetattr.c
 * 获取消息队列的属性
 * 属性有四项：flag, maxmsg, msgsize, curmsgs;
 * 其中：
 * 1.消息队列的最大容量和每个消息的最大长度只能在创建的时候设置,手动检查是否为0
 * 2.flag只有是否阻塞两个选项，可以随意随时设置
 * 3.当前消息队列的消息的个数，任何时候不能设置，只能获取
 */
#include <fcntl.h>
#include <sys/stat.h>
#include <mqueue.h>
#include <stdio.h>
#include <stdlib.h>
#define MQNAME "/temp.1"
#define MODE (S_IRWXU | S_IRWXG | S_IRWXO)
int main(int argc, char **agrv)
{
    mqd_t mqd;
    struct mq_attr attr;
    mqd = mq_open(MQNAME, O_RDWR, MODE, NULL);
    mq_getattr(mqd, &attr);
    printf("flag:%ld\tmaxmsg:%ld\tmsgsize:%ld\tcurmsgs:%ld\n", attr.mq_flags, attr.mq_maxmsg, attr.mq_msgsize, attr.mq_curmsgs);
    mq_close(mqd);
    exit(0);
}

取消息和推送消息

推送消息：

/**
 * @file mqsend.c
 * 往消息队列上发送消息,消息有优先级
 */
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <mqueue.h>
#include <string.h>
#define MQNAME "/temp.1234"
#define MSG1 "this is a msg, prio = 10."
#define MSG2 "this is a msg, prio = 20."
int main(int argc, char **argv)
{
    char *buf;
    size_t buf_len = 1024;
    unsigned int prio1 = 10;
    unsigned int prio2 = 20;
    mqd_t mqd;

    // 打开消息队列
    mqd = mq_open(MQNAME, O_RDWR);
    if (mqd == (mqd_t)-1)
    {
        perror("mq_open");
        exit(-1);
    }

    // 申请缓冲区内存
    buf = (char *)malloc(buf_len);
    if (buf == NULL)
    {
        fprintf(stderr, "malloc\n");
        exit(-1);
    }

    
    // 发送
    strncpy(buf, MSG1, sizeof(MSG1));
    if (mq_send(mqd, buf, buf_len, prio1) < 0)
    {
        perror("mq_send");
        exit(-1);
    }
    strncpy(buf, MSG2, sizeof(MSG2));
    if (mq_send(mqd, buf, buf_len, prio2) < 0)
    {
        perror("mq_send");
        exit(-1);
    }

    free(buf);
    mq_close(mqd);
    exit(0);
}

接受消息：

/**
 * @file 3-mqreceive.c
 * 接受消息，阻塞
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <mqueue.h>
#include <string.h>
#include <strings.h>
#define MQNAME "/temp.1234"
int main(int argc, char **argv)
{
    char *buf;
    long buf_len;
    mqd_t mqd;
    struct mq_attr attr;
    // 打开消息队列
    mqd = mq_open(MQNAME, O_RDONLY);
    if (mqd == (mqd_t)-1)
    {
        perror("mq_open");
        exit(-1);
    }

    // 获取消息队列的属性
    bzero(&attr, sizeof(attr));
    mq_getattr(mqd, &attr);
    buf_len = attr.mq_msgsize;

    // 给buf申请内存
    buf = (char *)malloc(buf_len);
    if (buf == NULL)
    {
        fprintf(stderr, "malloc\n");
        mq_close(mqd);
        exit(-1);
    }

    // 接受消息
    // prio == 0, 表示接受优先级最高的，可以指定优先级
    // 如果指定的优先级不存在，就接受最高优先级
    unsigned int prio = 20;
    bzero(buf, buf_len);
    mq_receive(mqd, buf, buf_len, &prio);
    printf("msg:%s\n", buf);
    bzero(buf, buf_len);
    mq_receive(mqd, buf, buf_len, &prio);
    printf("msg:%s\n", buf);

    exit(0);
}

使用mq_notify()通知接收消息

/**
 * @file 4-1mqnotify.c
 * 简单的信号通知
 * 
 * 使用消息队列异步通知
 * 1.mq_notify是一次性的,想要多次使用，必须重复注册
 * 2.任意时刻任何进程，只能有一个注册接受通知
 * 3.空指针代表注销通知
 * 4.receive的阻塞比通知优先级高
 */
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <signal.h>
#include <string.h>
#include <strings.h>
#include <mqueue.h>
#include <unistd.h>
#define MQNAME "/temp.1234"

mqd_t mqd;
void *buf;
long buf_len;
struct mq_attr attr;
struct sigevent sigev;

/**
 * 信号处理函数
 */
static void sig_usr(int p)
{
    // 重新注册
    mq_notify(mqd, &sigev);

    // 收到信号就去消息队列里取消息
    mq_receive(mqd, (char*)buf, buf_len, NULL);
    printf("msg:%s\n", buf);

    // 清空
    bzero(buf, buf_len);

    return;
}
    
int main(int argc, char **argv)
{
    // 打开消息队列
    mqd = mq_open(MQNAME, O_RDWR);
    if (mqd == (mqd_t)-1)
    {
        perror("mq_open");
        exit(-1);
    }

    // 获取属性
    mq_getattr(mqd, &attr);

    // 获取最大size
    buf_len = attr.mq_msgsize;

    // buf申请内存
    buf = (void *)malloc(buf_len);
    if (buf == NULL)
    {
        fprintf(stderr, "malloc\n");
        exit(-1);
    }

    // 注册信号
    signal(SIGUSR1, sig_usr);

    // 设置信号响应
    bzero(&sigev, sizeof(sigev));
    sigev.sigev_notify = SIGEV_SIGNAL;
    sigev.sigev_signo = SIGUSR1;

    // 注册通知者
    if (mq_notify(mqd, &sigev) < 0)
    {
        perror("mq_notify");
        exit(-1);
    }

    for ( ;; )
    {
        sleep(1);
    }

    exit(0);
}

由于非实时信号会丢失，下列代码使用阻塞信号改进，并改用非阻塞读取：

/**
 * @file 4-2mqnotify.c
 * 非阻塞的mq_notify的信号通知
 * 使用阻塞信号临界区
 * 注意信号的很多东西得是gnuc标准
 */
#include <signal.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <mqueue.h>
#include <errno.h>
#define MQNAME "/temp.1234"
volatile sig_atomic_t mqflag;
static void sig_user1(int p);

int main(int argc, char **argv)
{
    mqd_t mqd;
    void *buf;
    sigset_t zeromask, newmask, oldmask;
    struct mq_attr attr;
    struct sigevent sigev;

    // 非阻塞打开消息队列
    mqd = mq_open(MQNAME, O_RDONLY | O_NONBLOCK);
    if (mqd == (mqd_t)-1)
    {
        perror("mq_open");
        exit(-1);
    }

    // 获取消息队列的属性
    mq_getattr(mqd, &attr);

    // 给存储区申请内存
    buf = malloc(attr.mq_msgsize);

    // 清空信号屏蔽字
    sigemptyset(&zeromask);
    sigemptyset(&newmask);
    sigemptyset(&oldmask);

    // 添加阻塞信号
    sigaddset(&newmask, SIGUSR1);

    // 注册信号处理函数
    signal(SIGUSR1, sig_user1);

    // 设置通知信号
    sigev.sigev_notify = SIGEV_SIGNAL;
    sigev.sigev_signo = SIGUSR1;

    // 注册信号通知
    mq_notify(mqd, &sigev);

    // 循环等待信号
    while (1)
    {
        // 阻塞信号，形成信号临界区代码,这个函数不能在多线程中使用，因为我们应该只改变当前线程的掩码
        sigprocmask(SIG_BLOCK, &newmask, &oldmask);

        // 这中间得代码不能被信号打断，来的信号全部排队阻塞

        // 从阻塞队列里取出一个信号处理
        while (mqflag == 0)
        {
            // 暂停阻塞，暂停线程，直到某个某个信号从处理函数返回
            // 相当用从信号临界区，取出一个阻塞的信号，原子地等待它的处理函数执行完毕
            // 然后再将临界区封闭，继续阻塞信号
            sigsuspend(&zeromask);
        }

        // 重新设置等待条件
        mqflag = 0;
        mq_notify(mqd, &sigev);

        // 读数据
        ssize_t n;
        while ((n = mq_receive(mqd, (char*)buf, attr.mq_msgsize, NULL)) >= 0)
        {
            printf("msg:%s\n", buf);
        }

        // 判断错误,因为mqd是非阻塞的，所以如果的读的时候没有数据，就以EAGAIN错误返回
        // 但是这个错误不是程序错误
        if (errno != EAGAIN) 
        {
            perror("mq_receive");
            mq_close(mqd);
            exit(-1);
        }

        // 接触阻塞，临界区代码下边界
        sigprocmask(SIG_UNBLOCK, &newmask, NULL);
    }
    exit(0);
}
void sig_user1(int p)
{
    mqflag = 1;
    return;
}

使用sigwait改进上述代码，提升效率。

/**
 * @file 4-3mqnotify.c
 * 使用sigwait代替sigsuspend
 * 注意，我们一直使用的是signal
 * 这个函数是有缺陷的，因为它会在执行一个信号处理函数的时候，被另一个信号打断而跑去执行另一个，
 * 虽然可以返回来，但是返回的环境可能会不同。
 * 如果不想信号在处理函数中被别的信号打断，应该使用sigaction()函数。
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <mqueue.h>
#include <signal.h>
#include <errno.h>
#define MQNAME "/temp.1234"
int main(int agrc, char **argv)
{
    mqd_t mqd;
    void *buf;
    struct mq_attr attr;

    mqd = mq_open(MQNAME, O_RDONLY | O_NONBLOCK);
    if (mqd == (mqd_t)-1)
    {
        perror("mq_open");
        exit(-1);
    }

    mq_getattr(mqd, &attr);

    buf = malloc(attr.mq_msgsize);
    if (buf == NULL)
    {
        fprintf(stderr, "malloc failed.\n");
        exit(-1);
    }

    sigset_t newmask;
    sigemptyset(&newmask);
    sigaddset(&newmask, SIGUSR1);

    sigprocmask(SIG_BLOCK, &newmask, NULL);

    struct sigevent sigev;
    sigev.sigev_notify = SIGEV_SIGNAL;
    sigev.sigev_signo = SIGUSR1;

    mq_notify(mqd, &sigev);

    while (1)
    {
        int signo;
        // 这个参数是信号集，信号集和信号屏蔽字本质都是sigset_t类型的位图，这里信号集中只有SIGUSR1
        // 而做阻塞用的时候，也是只阻塞SIGUSR1
        // 这个函数可以用在多线程里，因为它执行的时候会暂时挂起线程，只返回响应的信号，并把信号编号填充signo
        sigwait(&newmask, &signo);

        if (signo == SIGUSR1)
        {
            // 读
            mq_notify(mqd, &sigev);
            int n;
            while ((n = mq_receive(mqd, (char *)buf, attr.mq_msgsize, NULL)) >= 0)
            {
                printf("msg:%s\n", buf);
            }
            if (errno != EAGAIN)
            {
                perror("mq_receive");
                exit(-1);
            }
        }
    }
}

使用select改进代码：

/**
 * @file 4-4mqnotify.c
 * 使用select
 * 因为mqd_t文件描述符不是普通的文件描述符，不能直接用于select
 * 所以我们需要桥接，管道描述符可以用与select，可以使用管道描述符和信号进行桥接
 */
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <mqueue.h>
#include <signal.h>
#include <errno.h>
#define MQNAME "/temp.1234"
int pipefd[2];
static void sig_usr(int p)
{
    // 写的目的就是为了触发select的活动
    write(pipefd[1], " ", 1);
    return;
}

int main(int argc, char **argv)
{
    mqd_t mqd;
    void *buf;
    struct mq_attr attr;

    mqd = mq_open(MQNAME, O_RDONLY | O_NONBLOCK);
    if (mqd == (mqd_t)-1)
    {
        perror("mq_open");
        exit(-1);
    }

    mq_getattr(mqd, &attr);

    buf = malloc(attr.mq_msgsize);
    if (buf == NULL)
    {
        fprintf(stderr, "malloc failed.\n");
        exit(-1);
    }

    // 新建一个管道
    pipe(pipefd);

    signal(SIGUSR1, sig_usr);

    struct sigevent sigev;
    sigev.sigev_notify = SIGEV_SIGNAL;
    sigev.sigev_signo = SIGUSR1;
    mq_notify(mqd, &sigev);

    // 文件描述符集，防止需要select监听的描述符
    fd_set fset;
    // 先清空
    FD_ZERO(&fset);

    while (1)
    {
        // 把管道的读端添加到文件描述符集合
        FD_SET(pipefd[0], &fset);

        // 最大描述符， 监听读，监听写，监听错误，时间
        select(pipefd[0] + 1, &fset, NULL, NULL, NULL);

        // 检查响应的是不是pipefd[0]
        // 活动的描述符被保留，未活动的会被select设置为0，所以每次循环都要重置fset
        // 同样这个fset也会被整个拷贝道内核中
        if(FD_ISSET(pipefd[0], &fset))
        {
            char ch;
            read(pipefd[0], &ch, 1);    // 把标记字符读出来

            mq_notify(mqd, &sigev);

            int n;
            while ((n = mq_receive(mqd, (char*)buf, attr.mq_msgsize, NULL)) >= 0)
            {
                printf("msg:%s\n", buf);
            }
            if (errno != EAGAIN)
            {
                perror("mq_receive");
                exit(-1);
            }
        }
    }
    exit(0);
}

正统的mq_notify()用法——调用线程

/**
 * @file 4-5mqnotify.c
 * 使用mq_notify()的正统用法——调用线程
 */
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/stat.h>
#include <errno.h>
#include <signal.h>
#include <mqueue.h>
#define MQNAME "/temp.1234"

mqd_t mqd;
struct mq_attr attr;
struct sigevent sigev;

static void notify_thread(union sigval sv)
{
    int n;
    void *buf;
    buf = malloc(attr.mq_msgsize);
    if (buf == NULL)
    {
        fprintf(stderr, "malloc failed.\n");
        exit(-1);
    }
    mq_notify(mqd, &sigev);

    while ((n = mq_receive(mqd, (char *)buf, attr.mq_msgsize, NULL)) >= 0)
    {
        printf("msg:%s\n", buf);
    }
    if (errno != EAGAIN)
    {
        perror("mq_receive");
        exit(-1);
    }
    free(buf);
    pthread_exit(NULL);
}

int main()
{
    mqd = mq_open(MQNAME, O_RDONLY | O_NONBLOCK);
    if (mqd == (mqd_t)-1)
    {
        perror("mq_open");
        exit(-1);
    }

    mq_getattr(mqd, &attr);

    sigev.sigev_notify = SIGEV_THREAD;
    sigev.sigev_value.sival_ptr = NULL;
    sigev.sigev_notify_function = notify_thread;
    sigev.sigev_notify_attributes = NULL;

    mq_notify(mqd, &sigev);
    
    while (1)
    {
        pause();
    }
    exit(0);
}
【RK3588嵌入式Linux系统编程】-POSIX消息队列
视觉与物联智能
06-23 702
本文将详细介绍如何在Linux中进行POSIX队列编程。
linuxC多进程通讯---POSIX消息队列
qq_23929673的博客
01-27 498
文章目录posix与system v对比POSIX 编程注意事项相关API创建或打开 IPC 对象•函数原型：•函数功能：•函数参数:•函数返回值关闭POSIX 消息队列•函数原型：•函数功能：•TIPS：•删除一个POSIX 消息队列•函数原型：•函数功能：•向 POSIX 消息队列写入消息•函数原型：•函数功能：•函数参数：•从 POSIX 消息队列读取消息•函数功能：•函数参数：•函数返回值...
POSIX 消息队列
奋斗在路上的博客
11-26 876
一、什么是 POSIX 消息队列？POSIX 消息队列 是一种用于进程间通信（IPC）的技术，它允许不同进程之间通过发送和接收消息来进行通信。POSIX 消息队列是基于 POSIX 标准的一部分，旨在提供跨平台的兼容性和一致性。通俗解释想象一下，你和你的朋友在不同的房间里，你们需要传递信息给对方。传统的做法可能是大喊大叫，但这种方式不太可靠。更好的方法是使用一个小盒子（消息队列），你们可以把信息写在纸上，放进这个盒子里。当你有信息要传递给你的朋友时，你可以把纸条放进盒子；
Posix消息队列
ZX714311728的博客
11-17 1312
1.消息队列 消息队列可以认为是一个消息链表，消息队列是随内核持续的。队列中每个消息的属性有：一个无符号整数优先级(Poxis)或一个长整数类型(System V)；消息的数据部分长度(可以为0)；数据本身。链表头含有当前队列的两个属性：队列中运行的最大消息数、每个消息的最大大小。消息队列的可能布局如下： Posix消息队列与System V消息队列主要区别： 1.对Posix消息队
《网络编程卷2：进程间通信》第五章：POSIX消息队列深度解析与高性能实践
最新发布
SEU123WW的博客
02-14 995
POSIX消息队列凭借其高效的优先级管理和灵活的异步机制，成为高实时性系统的首选IPC方案。本文从内核实现到应用实践，详细剖析了其核心机制，并给出了多场景代码示例。容错设计：处理进程崩溃导致的半开队列。访问控制：结合Linux Capabilities限制队列访问权限。监控工具：使用查看队列状态，调整内核参数。扩展阅读ZeroMQ：基于消息队列的分布式通信框架。RDMA：绕过内核的高性能网络通信技术。掌握POSIX消息队列，不仅能够构建高效进程间通信系统，更为理解现代分布式消息中间件奠定基础。
POSIX消息队列
IT民工的蜕变
04-15 631
消息队列 一、函数 mq_open 头文件 mqueue.h；   原型 mqd_t mq_open(const char *name, int oflag, .../*mode_t mode,struct mq_attr* attr*/);   函数功能 创建消息队列；   参数 name ：消息队列的名字，根据消息队
QNX-UNIX-POSIX-C函数手册-chm格式.7z
12-01
《QNX-UNIX-POSIX-C函数手册》是一份针对编程初学者的宝贵资源，尤其适合那些在Linux环境中使用C语言进行开发的程序员。这份手册详细介绍了C语言标准库以及与QNX、UNIX和POSIX操作系统相关的扩展函数，旨在帮助...
unix编程——posix消息队列.docx
10-30
POSIX消息队列是Unix和类Unix系统中提供的一种进程间通信（IPC）机制，它允许进程之间通过消息传递进行通信。在提供的代码示例中，`send.c`和`recv.c`分别展示了如何发送和接收消息到一个名为`/temp.1234`的消息队列...
mqueue:一个为windows获取POSIX消息队列的实验项目
06-04
POSIX消息队列则提供了这样的功能，它允许进程将消息按照先进先出（FIFO）的顺序放入队列，并可以设置消息的优先级。 该项目“mqueue”可能是通过以下几种方式来实现的： 1. **模拟实现**：通过Windows API或者...
UNIX消息队列
jishublog
05-28 216
在WNDOWS里面消息是很重要的，是WINDOWS的驱动机制，在UNIX当中也含有消息机构，即消息队列，通常用一个消息队列号（KEY，类似于文件描述符来标识文件）标识，通过把一个进程的消息发送进消息队列，其他进程从这个消息队列取消息的方法实现进程通信。消息包含类型，数据长度，数据内容属性，类型和数据长度位于消息首部中，在消息首部中，有指向数据区的指针以及消息队列的链接指针等。 消息机制过程， ...
posix消息队列
lovelirui的专栏
03-02 1382
1.创建一个posix消息队列,队列名又标准输入传进增加排他性选项;2.从系统中删除一个消息队列3.获取一个消息队列的属性4.创建一个posix消息队列,队列名又标准输入传进增加排他性选项;创建的时候指定 消息队列最大消息数,每个消息的大小;由标准输入传进5.向一个队列中增加一个消息6.从一个消息队列中读一个消息,增加非堵塞性;要获取队列的属性,才可分配空间7.调用sysconf函数,输出 一个进程可打开多少消息队列, 任意消息的最大优先级
UNIX环境高级编程——system V消息队列
weixin_34238642的博客
07-08 202
unix早期通信机制中的信号能够传送的信息量有限，管道则只能传送无格式字节流，这远远是不够的。 消息队列（也叫报文队列）客服了这些缺点： 消息队列就是一个消息的链表。 可以把消息看作一个记录，具有特定的格式。 进程可以按照一定的规则向消息队列中添加新消息；另一些进程可以从消息队列中读走消息。 消息队列是随内核持续的，只有内核重启或人工删除时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

虚知道

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

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

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

打赏作者

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

抵扣说明：

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

余额充值