linux下实现System V消息队列实现任意结构体传输

原创 已于 2025-08-14 10:32:10 修改 · 214 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #算法 #运维

于 2025-08-07 17:09:26 首次发布

以下是一个实现，可以发送和接收任意类型的结构体消息，而不仅限于特定的CustomMsg类型：

// queue.c
#include <unistd.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <stdio.h>
#include "queue.h"
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/time.h>
#include "all.h"

SafeQueue* queue_create(int size) {
    SafeQueue *q = malloc(sizeof(SafeQueue));
    q->buffer = malloc(size);
    q->size = size;
    q->head = q->tail = q->count = 0;
    pthread_mutex_init(&q->lock, NULL);
    pthread_cond_init(&q->not_empty, NULL);
    pthread_cond_init(&q->not_full, NULL);
    return q;
}

void queue_destroy(SafeQueue *q) {
    if (q) {
        pthread_mutex_destroy(&q->lock);
        pthread_cond_destroy(&q->not_empty);
        pthread_cond_destroy(&q->not_full);
        free(q->buffer);
        free(q);
    }
}

bool queue_put(SafeQueue *q, const uint8_t *data, int len) {
    pthread_mutex_lock(&q->lock);
    
    while (q->count + len > q->size) {
        if (pthread_cond_wait(&q->not_full, &q->lock) != 0) {
            pthread_mutex_unlock(&q->lock);
            return false;
        }
    }
    
    // 循环缓冲区写入
    int first_chunk = q->size - q->tail;
    if (len <= first_chunk) {
        memcpy(q->buffer + q->tail, data, len);
        q->tail = (q->tail + len) % q->size;
    } else {
        memcpy(q->buffer + q->tail, data, first_chunk);
        memcpy(q->buffer, data + first_chunk, len - first_chunk);
        q->tail = len - first_chunk;
    }
    
    q->count += len;
    pthread_cond_signal(&q->not_empty);
    pthread_mutex_unlock(&q->lock);
    return true;
}

int queue_get(SafeQueue *q, uint8_t *buffer, int max_len, int timeout_ms) {
    struct timespec ts;
    struct timeval tv;
    
    pthread_mutex_lock(&q->lock);
    
    if (q->count == 0) {
        if (timeout_ms == 0) {
            pthread_mutex_unlock(&q->lock);
            return 0;
        }
        
        gettimeofday(&tv, NULL);
        ts.tv_sec = tv.tv_sec + timeout_ms / 1000;
        ts.tv_nsec = tv.tv_usec * 1000 + (timeout_ms % 1000) * 1000000;
        if (ts.tv_nsec >= 1000000000) {
            ts.tv_sec++;
            ts.tv_nsec -= 1000000000;
        }
        
        if (pthread_cond_timedwait(&q->not_empty, &q->lock, &ts) != 0) {
            pthread_mutex_unlock(&q->lock);
            return 0;
        }
    }
    
    if (q->count == 0) {
        pthread_mutex_unlock(&q->lock);
        return 0;
    }
    
    int to_read = (q->count < max_len) ? q->count : max_len;
    
    // 循环缓冲区读取
    int first_chunk = q->size - q->head;
    if (to_read <= first_chunk) {
        memcpy(buffer, q->buffer + q->head, to_read);
        q->head = (q->head + to_read) % q->size;
    } else {
        memcpy(buffer, q->buffer + q->head, first_chunk);
        memcpy(buffer + first_chunk, q->buffer, to_read - first_chunk);
        q->head = to_read - first_chunk;
    }
    
    q->count -= to_read;
    pthread_cond_signal(&q->not_full);
    pthread_mutex_unlock(&q->lock);
    return to_read;
}

int queue_count(SafeQueue *q) {
    pthread_mutex_lock(&q->lock);
    int count = q->count;
    pthread_mutex_unlock(&q->lock);
    return count;
}

//================================实现任意结构体消息队列========add by luo 250807=====================================
// 错误处理宏
#define ERROR_EXIT(msg) do { perror(msg); exit(EXIT_FAILURE); } while(0)

// 创建消息队列
#if 0
int create_message_queue(key_t key) {
    int msgid;
    
    // 创建消息队列 (IPC_CREAT | IPC_EXCL | 0666)
    if ((msgid = msgget(key, IPC_CREAT | IPC_EXCL | 0666)) == -1) {
        if (errno == EEXIST) {
            // 如果已存在，则直接获取
            msgid = msgget(key, 0666);
            if (msgid == -1) {
                ERROR_EXIT("msgget failed to get existing queue");
            }
        } else {
            ERROR_EXIT("msgget failed to create new queue");
        }
    }
    return msgid;
}
#endif

int create_message_queue(key_t key) {
    int msgid;
    struct msqid_ds buf;

    // 尝试新建队列
    if ((msgid = msgget(key, IPC_CREAT | IPC_EXCL | 0666)) == -1) {
        if (errno == EEXIST) {
            // 获取现有队列
            if ((msgid = msgget(key, 0666)) == -1) {
                ERROR_EXIT("msgget failed to get existing queue");
            }
            
            // ==== 新增：清空队列中的遗留消息 ====
            if (msgctl(msgid, IPC_STAT, &buf) == -1) 
            {
                perror("msgctl(IPC_STAT) failed");
            } 
            else 
            {
                while (buf.msg_qnum > 0) { // 当队列中有消息时
                    char dummy[buf.__msg_cbytes]; // 准备足够大的缓冲区
                    if (msgrcv(msgid, &dummy, sizeof(dummy), 0, IPC_NOWAIT) == -1) {
                        if (errno != ENOMSG) perror("msgrcv(flush) failed");
                        break;
                    }
                    msgctl(msgid, IPC_STAT, &buf); // 更新队列状态
                }
                printf("Flushed %lu messages from existing queue\n", buf.msg_qnum);
            }
            // ====== 清空结束 ======
        } else {
            ERROR_EXIT("msgget failed to create new queue");
        }
    }
    return msgid;
}


// 发送任意结构体消息
// msg: 指向包含MSG_HEADER的结构体指针
// msg_size: 结构体总大小
void send_struct_message(int msgid, void *msg, size_t msg_size) {
    // 计算实际数据大小 (减去mtype的大小)
    size_t data_size = msg_size - sizeof(long);
    
    if (msgsnd(msgid, msg, data_size, IPC_NOWAIT) == -1) {
        ERROR_EXIT("msgsnd failed");
    }
    printf("Sent %zu byte message (type %ld)\n", msg_size, ((long*)msg)[0]);
}

// 接收任意结构体消息
// msg: 指向包含MSG_HEADER的结构体指针
// msg_size: 结构体总大小
// msg_type: 期望接收的消息类型
//阻塞接收方式
void receive_struct_message(int msgid, void *msg, size_t msg_size, long msg_type) {
    // 计算实际数据大小 (减去mtype的大小)
    size_t data_size = msg_size - sizeof(long);
    
    ssize_t bytes = msgrcv(msgid, msg, data_size, msg_type, 0);
    if (bytes == -1) {
        ERROR_EXIT("msgrcv failed");
    }
    printf("Received %zd byte message (type %ld)\n", bytes + sizeof(long), ((long*)msg)[0]);
}

// 非阻塞接收任意结构体消息
int receive_struct_message_nonblocking(int msgid, void *msg, size_t msg_size, long msg_type) {
    size_t data_size = msg_size - sizeof(long);
    
    ssize_t bytes = msgrcv(msgid, msg, data_size, msg_type, IPC_NOWAIT);
    if (bytes == -1) 
    {
        if (errno == ENOMSG) {
            // 没有消息不是错误，只是需要重试
            return false;
        }
        ERROR_EXIT("msgrcv failed");
    }
    printf("Received %zd byte message (type %ld) [non-blocking]\n",bytes + sizeof(long), ((long*)msg)[0]);
    return true;
}

// 删除消息队列
#if 0
void remove_message_queue(int msgid) {
    if (msgctl(msgid, IPC_RMID, NULL) == -1) {
        if (errno != EIDRM) { // 忽略已删除的错误
            perror("msgctl IPC_RMID failed");
        }
    }
}
#endif

void remove_message_queue(int msgid) {
    // 清空消息后再删除队列
    struct msqid_ds buf;
    if (msgctl(msgid, IPC_STAT, &buf) == 0) {
        while (buf.msg_qnum > 0) {
            char dummy[4096];
            msgrcv(msgid, &dummy, sizeof(dummy), 0, IPC_NOWAIT);
            msgctl(msgid, IPC_STAT, &buf);
        }
    }
    msgctl(msgid, IPC_RMID, NULL); // 删除队列
}


// ===================== 使用示例 =====================
#if 0
typedef struct {
    MSG_HEADER;
    int counter;
    char data[64];
} TestMessage;

int main() {
    int msgid = create_message_queue(MSG_QUEUE_KEY);
    pid_t pid = fork();
    
    if (pid < 0) {
        ERROR_EXIT("fork failed");
    }
    
    if (pid > 0) { // 父进程 - 发送者
        sleep(1);  // 等待接收者准备
        
        // 发送3条消息
        for (int i = 1; i <= 3; i++) {
            TestMessage msg = {
                .mtype = 1,
                .counter = i,
                .data = "Blocking test"
            };
            send_struct_message(msgid, &msg, sizeof(TestMessage));
            sleep(1);
        }
        
        // 发送快速连续消息
        for (int i = 4; i <= 6; i++) {
            TestMessage msg = {
                .mtype = 2,
                .counter = i,
                .data = "Non-blocking test"
            };
            send_struct_message(msgid, &msg, sizeof(TestMessage));
        }
        
        // 等待接收者处理
        sleep(2);
        remove_message_queue(msgid);
        
    } else { // 子进程 - 接收者
        // 1. 阻塞接收演示
        printf("=== Blocking Receive Test ===\n");
        for (int i = 0; i < 3; i++) {
            TestMessage msg;
            if (receive_struct_message_blocking(msgid, &msg, sizeof(TestMessage), 1)) {
                printf("Blocking received: counter=%d, data=%s\n", 
                       msg.counter, msg.data);
            }
        }
        
        // 2. 非阻塞接收演示
        printf("\n=== Non-blocking Receive Test ===\n");
        int received = 0;
        while (received < 3) {
            TestMessage msg;
            if (receive_struct_message_nonblocking(msgid, &msg, sizeof(TestMessage), 2)) {
                printf("Non-blocking received: counter=%d, data=%s\n", 
                       msg.counter, msg.data);
                received++;
            } else {
                printf("No message available, doing other work...\n");
                sleep(1); // 模拟其他工作
            }
        }
        
        // 3. 超时接收演示
        printf("\n=== Timeout Receive Test ===\n");
        TestMessage msg;
        if (receive_struct_message_timeout(msgid, &msg, sizeof(TestMessage), 3, 2)) {
            printf("Received message within timeout\n");
        } else {
            printf("Timeout waiting for message (type 3)\n");
        }
    }
    
    return EXIT_SUCCESS;
}
#endif

  1. 消息队列限制：

    • 使用msgctl(IPC_STAT)检查队列状态

    • 监控队列使用情况，避免溢出

这个实现提供了高度灵活的消息传递机制，适用于各种嵌入式场景，从简单的传感器数据采集到复杂的设备控制命令，都可以通过定义适当的结构体来实现高效通信。

=========================阻塞和非阻塞接收方式===============================

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <stdbool.h>

// 通用消息头要求
#define MSG_HEADER long mtype

// 消息队列配置
#define MSG_QUEUE_KEY 0x1234

// 错误处理宏
#define ERROR_EXIT(msg) do { perror(msg); exit(EXIT_FAILURE); } while(0)

// 创建消息队列
int create_message_queue(key_t key) {
    int msgid = msgget(key, IPC_CREAT | 0666);
    if (msgid == -1) {
        ERROR_EXIT("msgget failed");
    }
    return msgid;
}

// 发送任意结构体消息（阻塞）
void send_struct_message(int msgid, void *msg, size_t msg_size) {
    size_t data_size = msg_size - sizeof(long);
    
    if (msgsnd(msgid, msg, data_size, 0) == -1) {  // 阻塞发送
        ERROR_EXIT("msgsnd failed");
    }
    printf("Sent %zu byte message (type %ld)\n", 
           msg_size, ((long*)msg)[0]);
}

// 阻塞接收任意结构体消息
bool receive_struct_message_blocking(int msgid, void *msg, size_t msg_size, long msg_type) {
    size_t data_size = msg_size - sizeof(long);
    
    ssize_t bytes = msgrcv(msgid, msg, data_size, msg_type, 0);
    if (bytes == -1) {
        return false;
    }
    printf("Received %zd byte message (type %ld) [blocking]\n", 
           bytes + sizeof(long), ((long*)msg)[0]);
    return true;
}

// 非阻塞接收任意结构体消息
bool receive_struct_message_nonblocking(int msgid, void *msg, size_t msg_size, long msg_type) {
    size_t data_size = msg_size - sizeof(long);
    
    ssize_t bytes = msgrcv(msgid, msg, data_size, msg_type, IPC_NOWAIT);
    if (bytes == -1) {
        if (errno == ENOMSG) {
            // 没有消息不是错误，只是需要重试
            return false;
        }
        ERROR_EXIT("msgrcv failed");
    }
    printf("Received %zd byte message (type %ld) [non-blocking]\n", 
           bytes + sizeof(long), ((long*)msg)[0]);
    return true;
}

// 带超时的接收（混合模式）
bool receive_struct_message_timeout(int msgid, void *msg, size_t msg_size, 
                                   long msg_type, int timeout_sec) {
    for (int i = 0; i < timeout_sec * 10; i++) {
        if (receive_struct_message_nonblocking(msgid, msg, msg_size, msg_type)) {
            return true;
        }
        // 等待100ms后重试
        usleep(100 * 1000);
    }
    return false;
}

// 删除消息队列
void remove_message_queue(int msgid) {
    if (msgctl(msgid, IPC_RMID, NULL) == -1 && errno != EIDRM) {
        perror("msgctl IPC_RMID failed");
    }
}

// ===================== 使用示例 =====================

typedef struct {
    MSG_HEADER;
    int counter;
    char data[64];
} TestMessage;

int main() {
    int msgid = create_message_queue(MSG_QUEUE_KEY);
    pid_t pid = fork();
    
    if (pid < 0) {
        ERROR_EXIT("fork failed");
    }
    
    if (pid > 0) { // 父进程 - 发送者
        sleep(1);  // 等待接收者准备
        
        // 发送3条消息
        for (int i = 1; i <= 3; i++) {
            TestMessage msg = {
                .mtype = 1,
                .counter = i,
                .data = "Blocking test"
            };
            send_struct_message(msgid, &msg, sizeof(TestMessage));
            sleep(1);
        }
        
        // 发送快速连续消息
        for (int i = 4; i <= 6; i++) {
            TestMessage msg = {
                .mtype = 2,
                .counter = i,
                .data = "Non-blocking test"
            };
            send_struct_message(msgid, &msg, sizeof(TestMessage));
        }
        
        // 等待接收者处理
        sleep(2);
        remove_message_queue(msgid);
        
    } else { // 子进程 - 接收者
        // 1. 阻塞接收演示
        printf("=== Blocking Receive Test ===\n");
        for (int i = 0; i < 3; i++) {
            TestMessage msg;
            if (receive_struct_message_blocking(msgid, &msg, sizeof(TestMessage), 1)) {
                printf("Blocking received: counter=%d, data=%s\n", 
                       msg.counter, msg.data);
            }
        }
        
        // 2. 非阻塞接收演示
        printf("\n=== Non-blocking Receive Test ===\n");
        int received = 0;
        while (received < 3) {
            TestMessage msg;
            if (receive_struct_message_nonblocking(msgid, &msg, sizeof(TestMessage), 2)) {
                printf("Non-blocking received: counter=%d, data=%s\n", 
                       msg.counter, msg.data);
                received++;
            } else {
                printf("No message available, doing other work...\n");
                sleep(1); // 模拟其他工作
            }
        }
        
        // 3. 超时接收演示
        printf("\n=== Timeout Receive Test ===\n");
        TestMessage msg;
        if (receive_struct_message_timeout(msgid, &msg, sizeof(TestMessage), 3, 2)) {
            printf("Received message within timeout\n");
        } else {
            printf("Timeout waiting for message (type 3)\n");
        }
    }
    
    return EXIT_SUCCESS;
}

Linux进程间通信 -管道&消息队列
Lycorisradiata__的博客
04-23 583
进程间通信的目的： （1）数据传输：一个进程需要将它的数据发送给另一个进程； （2）资源共享：多个进程之间需要共享同样的资源； （3）通知事件：一个进程需要向另一个进程发送消息，通知它（它们）发生了某些事（比如子进程终止时要通知父进程）； （4）进程控制：有些进程希望完全控制另一个进程的执行，能够及时知道它的状态改变。 进程间通信（IPC）分类： （1）...
Linux进程间通信(IPC) - 消息队列
db_linux_driver的博客
10-09 934
描述了消息队列的进程间通信方式的原理和基本使用方法，以及通过示例代码来辅助说明
【Linux系统】进程间通信：System V IPC——消息队列和信号量
2402_82670467的博客
08-18 1316
本文介绍了SystemV IPC中的消息队列和信号量机制。消息队列允许进程通过内核维护的队列交换结构化消息，包含消息类型和内容，具有持久性、容量限制和权限控制特性。信号量本质是受保护的整型变量，通过PV原子操作实现资源互斥访问和进程同步，包含阻塞机制和等待队列管理。文章详细分析了两者的工作原理、内核数据结构（msqid_ds和semid_ds）和系统调用接口，并与共享内存进行对比，阐述了三者在SystemV IPC中的协同关系。最后解释了操作系统通过"先描述再组织"方式统一管理IPC资源
linux 进程间通信之 消息队列以及实例
ZCL的专栏
12-13 2381
linux 进程间通信三 消息队列以及实例 消息可以理解为写信给某个人，这里在应用中是告诉系统写信人和写信的内容就可以了， 别人会来看发信人是谁，如果不是自己想要的就放弃读信或者只要有消息自己就读取消息 消息队列就是按队列的方式处理很多消息，先发的最先被读 消息队列： http://www.2cto.com/os/201205/129794.html http://home
linux系统实现串口,Linux下实现串口读写操作
weixin_39954569的博客
04-29 1607
Linux下实现串口读写操作这里只贴串口读写操作部分代码，供大家参考学习用，该部分代码主要实现打开串口，配置串口参数波特率为115200、停止位1、数据位8、无校验位，发送2个数据，等待接收24个数据。代码是在QT窗体程序里实现，界面添加了了一个按钮，3个文本框，按下去发送2个数据，等待接收到24个数据后，把发送数据长度、接收数据长度、串口句柄在文本框显示出来。#include "mainwind...
SystemV消息队列揭秘：原理与实战
祯的博客
07-29 872
本文详细介绍了SystemV消息队列的原理和操作方法。消息队列作为Unix/Linux系统中的进程间通信机制，通过内核维护的消息链表实现进程间结构化数据传输。文章首先阐述了消息队列的基本概念、特性（如类型化消息、持久性）和典型应用场景。然后深入解析了内核数据结构msqid_ds和ipc_perm的组成及作用。重点讲解了四个关键系统调用：msgget()创建/获取队列，msgctl()管理队列，msgsnd()发送消息，msgrcv()接收消息，包括函数原型、参数解析、使用示例和注意事项。
Linux之管道，system V的共享内存，消息队列和信号量
weixin_74285822的博客
11-24 1274
匿名管道，命名管道，system V的共享内存，消息队列和信号量
Linux学习日记13：消息队列
2201_75969037的博客
11-17 769
Linux消息队列是一种高效的进程间通信(IPC)机制，通过内核维护的消息链表实现结构化数据传输。其核心特性包括：消息类型标识、异步通信、独立于进程存在等。SystemV消息队列提供了msgget(创建)、msgsnd(发送)、msgrcv(接收)和msgctl(控制)等关键函数。ftok函数用于生成共享键值，使不同进程能访问同一队列。示例代码展示了单进程和多进程间的消息传递，以及全双工通信的实现方式，最后通过父子进程实现双向消息传递。消息队列相比管道和信号能更好地支持结构化数据传输。
Linux进程间通讯三--消息队列
雪狼的博客
08-15 578
Linux 消息队列 进程间通讯
Linux进程间通信消息队列编程实例
综上所述，该压缩包中的两个C文件极有可能构成一对协作进程：一个负责封装并发送1KB大小的数据块至共享消息队列，另一个则持续监听并接收这些消息，完整展现了Linux下基于System V消息队列的进程通信模型。...
【并发程序设计】总篇集 Linux下 C语言 实现并发程序设计
2201_75563094的博客
06-03 2008
在Linux中，进程是操作系统分配资源和调度运行的基本单位。Linux中的进程有以下用处：进程在Linux系统中扮演着至关重要的角色，它们不仅提高了系统的资源利用率，还实现了多任务的并行处理，使得用户可以更加高效地进行工作。以下是一些关于Linux进程的重要概念：进程的内容通常包括以下几个主要部分：在Linux中，子进程是由父进程创建的进程。当一个进程被创建时，它会自动成为一个新进程的父进程，而新进程则成为子进程。子进程可以通过系统调用来创建。回收子进程的必要性：回收子进程不仅是为了维护操作系统资源的有效性
linux,消息队列
05-15
Linux消息队列是System V IPC机制的重要组成部分，支持不同进程间的结构化数据传输。以下是关键实现步骤和使用要点： #### 一、核心数据结构 ```c struct msgbuf { long mtype; // 必须>0的消息类型标识 char ...
AlmaLinux9配置本地镜像仓库
weixin_50877409的博客
12-04 186
本文介绍了在AlmaLinux 9.7系统中配置本地yum仓库的步骤：1）创建挂载目录并挂载ISO镜像；2）备份原有repo文件并创建local.repo配置文件；3）设置本地仓库路径为/media/cdrom/AppStream；4）清除并重建yum缓存；5）最后通过成功安装telnet包验证了本地仓库配置的正确性。整个过程实现了不依赖网络使用本地ISO镜像作为软件源的目的。
99-在Linux上安装Anaconda
12-03 210
【代码】99-在Linux上安装Anaconda。
Linux 进程状态与进程管理命令
qq_52537313的博客
12-04 813
在 Linux 系统中，是程序的运行实例，是操作系统资源分配和调度的基本单位。进程从创建到终止会经历多种状态，通过进程管理命令可以查看、监控和控制这些状态。本教程将结合核心命令，全方位讲解进程状态及管理方法。
Linux设备管理：从内核驱动到用户空间的完整架构解析
X
12-03 808
A[物理硬件插入/移除] --> B[内核驱动探测]B --> C{Linux统一设备模型 LDM}C --> D[在/sysfs创建对象]C --> E[发送uevent事件]D --> F[用户空间工具<br>lspci, lsusb等]E --> G[UDEV守护进程]G --> H[扫描规则库 /etc/udev/rules.d/]H --> I[匹配并执行规则]I --> J1[创建设备节点 /dev/]I --> J2[设置权限与所有权]I --> J3[执行自定义脚本]
【Linux】进程控制
Shengmc的博客
12-06 534
/ 执行 sh -c "echo $MY_ENV"：通过Shell解析环境变量// 自动从PATH找sh程序。
Linux物理内存管理-引导内存分配器
tang_vincent的博客
12-05 549
本文深入分析了Linux早期物理内存管理框架memblock的原理与实现。memblock作为引导内存分配器，在伙伴系统初始化前负责物理内存管理，通过memory数组记录总物理内存，reserved数组记录预留内存。文章详细解读了memblock的数据结构、初始化流程、关键接口(memblock_add/reserve/alloc/free等)实现，以及最终将内存释放到伙伴系统的过程。通过设备树解析获取物理内存范围，并对内核代码段、预留内存等特殊区域进行处理，memblock为内核启动阶段提供了可靠的内存管
Linux lftp命令
最新发布
菜鸟记录
12-07 207
⏹Linux lftp命令
Linux下基于消息队列的聊天程序设计与实现
要用C语言实现消息队列的聊天程序，首先需要具备扎实的C语言编程基础，包括但不限于基本数据类型、控制结构、数组和指针的使用、结构体等。此外，还需要了解C语言在Linux系统下的编程环境，包括如何在Linux环境下...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值