linux线程设置cpu亲和性与调度方式及优先级

最新推荐文章于 2024-09-07 10:29:16 发布
最新推荐文章于 2024-09-07 10:29:16 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： linux线程调度 文章标签： c语言 数据结构 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41039916/article/details/121428186
版权

cpus_set.c


#include "cpus_set.h"

int get_cpu_nums()
{
    return sysconf(_SC_NPROCESSORS_CONF);
}
int set_cpus_mask(int* cpus_arr, int nums, cpu_set_t *mask)
{
    CPU_ZERO(mask);
    if (nums > get_cpu_nums())
    {
        printf("%s:%d nums must less then cpu nums total\n", __FUNCTION__, __LINE__);
        return -1;
    }

    for (int i = 0; i < nums; i++)
    {
        if (cpus_arr[i] > (get_cpu_nums() - 1) || cpus_arr[i] < 0)
        {
            printf("cpus_arr[%d]: %d\n",i,cpus_arr[i]);
            printf("%s:%d cpus_arr error\n", __FUNCTION__, __LINE__);
            return -1;
        }
        CPU_SET(cpus_arr[i], mask); //将CPU号加入到mask集合
    }
    //printf("set_cpus_mask success\n");
    return 0;
}
int del_cpu_mask(int cpu_num, cpu_set_t *mask)
{
    if (!CPU_ISSET(cpu_num, mask))
    {
        printf("%s:%d cpu_num does not exist in mask\n", __FUNCTION__, __LINE__);
        return -1;
    }
    CPU_CLR(cpu_num, mask);
    return 0;
}
int bind_pthread_cpu_cores(cpu_set_t *mask, pthread_t pid)
{
    int ret = pthread_setaffinity_np(pid, sizeof(cpu_set_t), mask); /* 设置cpu 亲和性(affinity)*/
    if (ret < 0)
    {
        printf("%s:%d:", __FUNCTION__, __LINE__);
        perror("faild sched_setaffinity");
        return -1;
    }
    //printf("bind_cpu_cores success\n");
    return 0;
}
int bind_fork_cpu_cores(cpu_set_t *mask)
{

    int ret = sched_setaffinity(0, sizeof(cpu_set_t), mask);
    if (ret < 0)
    {
        printf("%s:%d:", __FUNCTION__, __LINE__);
        perror("faild sched_setaffinity");
        return -1;
    }
    //printf("bind_cpu_cores success\n");
    return 0;
}
void cpu_get(char* thread_name)
{
     usleep(10000);
    {
        int ret;
        cpu_set_t get_cpus;
        CPU_ZERO(&get_cpus);
        ret = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &get_cpus);
        if (ret < 0)
        {
            perror("faild sched_getaffinity");
        }
        printf("%s [%ld] is running in processor:",thread_name, pthread_self());
        for (int i = 0; i < 4; i++)
        {
            if (CPU_ISSET(i, &get_cpus))
            {
                printf("%d ", i);
            }
        }
        printf("\n");
    }
}
int create_pthread(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine)(void *), void *arg, int* cpus_arr,int nums)
{
    int ret;
    cpu_set_t mask;
    ret = set_cpus_mask(cpus_arr, nums, &mask);
    if (ret < 0)
    {
        printf("set_cpus_mask failed\n");
        return -1;
    }
    ret = pthread_create(thread, NULL, start_routine, arg);
    if (ret < 0)
    {
        printf("pthread_create failed\n");
        return -1;
    }
    ret = bind_pthread_cpu_cores(&mask, *thread);
    if (ret < 0)
    {
        printf("bind_pthread_cpu_cores failed\n");
        return -1;
    }
    
    usleep(100000);
}

int pthread_attribute_init(pthread_attr_t *attr){
    return pthread_attr_init(attr);
}
int pthread_attribute_destory(pthread_attr_t *attr){
    return pthread_attr_destroy(&attr);
}
int pthread_set_inheritsched(pthread_attr_t *attr,int __inherit){
    return pthread_attr_setinheritsched(attr, __inherit);
}
int pthread_set_schedpolicy(pthread_attr_t *attr,int policy){
    pthread_attr_setschedpolicy(attr, policy);
}

cpus_set.h


#ifndef __CPUS_SET_H__
#define __CPUS_SET_H__

#define _GNU_SOURCE
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sched.h>
#include <stdlib.h>

/*
    return : Number of CPU cores
*/
extern int get_cpu_num();
/*
    
*/
extern int set_cpus_mask(int *cpus_arr, int nums,cpu_set_t* mask);

extern int del_cpu_mask(int cpu_num,cpu_set_t* mask);

extern int bind_cpu_cores(cpu_set_t* mask,pthread_t pid);

extern int create_pthread(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine)(void *), void *arg, int *cpus_arr,int nunms);

#endif

main

#define _GNU_SOURCE

#include "cpus_set.h"
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sched.h>
#include <stdlib.h>
void printf_str(char *str)
{
    printf("%s", str);
}
void *thread_run1()
{
    usleep(10000);
    {
        int ret;
        cpu_set_t get_cpus;
        CPU_ZERO(&get_cpus);
        ret = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &get_cpus);
        if (ret < 0)
        {
            perror("faild sched_getaffinity");
        }
        printf("pthread_run1[%ld] is running in processor:", pthread_self());
        for (int i = 0; i < 4; i++)
        {
            if (CPU_ISSET(i, &get_cpus))
            {
                printf("%d ", i);
            }
        }
        printf("\n");
    }
    int policy;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    while (1)
    {
        //usleep(10000);
        //printf("pthtrad_run1 on cpu[%d] policy = %d ,param.__sched_priority = %d!\n", sched_getcpu(),policy,param.__sched_priority );
        printf_str("thread_run1 is running!\n");
    }
    pthread_exit(NULL);
}
void *thread_run2()
{
    usleep(10000);
    {
        int ret;
        cpu_set_t get_cpus;
        CPU_ZERO(&get_cpus);
        ret = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &get_cpus);
        if (ret < 0)
        {
            perror("faild sched_getaffinity");
        }
        printf("pthread_run2[%ld] is running in processor:", pthread_self());
        for (int i = 0; i < 4; i++)
        {
            if (CPU_ISSET(i, &get_cpus))
            {
                printf("%d ", i);
            }
        }
        printf("\n");
    }
    int policy;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    while (1)
    {
        //usleep(10000);
        //printf("pthtrad_run2 on cpu[%d] policy = %d ,param.__sched_priority = %d!\n", sched_getcpu(),policy,param.__sched_priority );
        printf_str("thread_run2 is running!\n");
    }
    pthread_exit(NULL);
}
void *thread_run3()
{
   
    int policy;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    while (1)
    {
        //usleep(10000);
        //printf("pthtrad_run3 on cpu[%d] policy = %d ,param.__sched_priority = %d!\n", sched_getcpu(),policy,param.__sched_priority );
        printf_str("thread_run3 is running!\n");
    }
    pthread_exit(NULL);
}
int main(int argc, char const *argv[])
{
    pthread_t th1, th2, th3;

    pthread_attr_t attr;
    struct sched_param sched;
    int ret;
    int cpu_arr1[1] = {0};
    cpu_set_t mask1;
    sched.__sched_priority = 99;
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); //要使优先级其作用必须要有这句话
    pthread_attr_setschedpolicy(&attr, SCHED_RR);                //改变线程调度策略
    pthread_attr_setschedparam(&attr, &sched);                   //设置线程优先级
    ret = create_pthread(&th1, &attr, thread_run1, NULL, cpu_arr1,sizeof(cpu_arr1)/sizeof(cpu_arr1[0]));
    if (ret < 0)
    {
        printf("%s:%d:create_pthread1 fail\n", __FUNCTION__, __LINE__);
    }
    pthread_attr_destroy(&attr);

    int cpu_arr2[1] = {0};
    cpu_set_t mask2;
    sched.__sched_priority = 50;
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); //要使优先级其作用必须要有这句话
    pthread_attr_setschedpolicy(&attr, SCHED_RR);                //改变线程调度策略
    pthread_attr_setschedparam(&attr, &sched);                   //设置线程优先级
    ret = create_pthread(&th2, &attr, thread_run2, NULL, cpu_arr2,sizeof(cpu_arr2)/sizeof(cpu_arr2[0]));
    if (ret < 0)
    {
        printf("%s:%d:create_pthread2 fail\n", __FUNCTION__, __LINE__);
    }
    pthread_attr_destroy(&attr);

    int cpu_arr3[1] = {0};
    cpu_set_t mask3;
    sched.__sched_priority = 1;
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); //要使优先级其作用必须要有这句话
    pthread_attr_setschedpolicy(&attr, SCHED_RR);                //改变线程调度策略
    pthread_attr_setschedparam(&attr, &sched);                   //设置线程优先级
    ret = create_pthread(&th3, &attr, thread_run3, NULL, cpu_arr3,sizeof(cpu_arr3)/sizeof(cpu_arr3[0]));
    if (ret < 0)
    {
        printf("%s:%d:create_pthread3 fail\n", __FUNCTION__, __LINE__);
    }
    pthread_attr_destroy(&attr);

    pthread_join(th1, NULL);
    pthread_join(th2, NULL);
    pthread_join(th3, NULL);

    return 0;
}
#if 0
#define _GNU_SOURCE

#include "cpus_set.h"
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sched.h>
#include <stdlib.h>
void printf_str(char *str)
{
    printf("%s", str);
}
void *thread_run1()
{
    usleep(10000);
    {
        int ret;
        cpu_set_t get_cpus;
        CPU_ZERO(&get_cpus);
        ret = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &get_cpus);
        if (ret < 0)
        {
            perror("faild sched_getaffinity");
        }
        printf("pthread_run1[%ld] is running in processor:", pthread_self());
        for (int i = 0; i < 4; i++)
        {
            if (CPU_ISSET(i, &get_cpus))
            {
                printf("%d ", i);
            }
        }
        printf("\n");
    }
    int policy;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    while (1)
    {
        //usleep(10000);
        //printf("pthtrad_run1 on cpu[%d] policy = %d ,param.__sched_priority = %d!\n", sched_getcpu(),policy,param.__sched_priority );
        printf_str("thread_run1 is running!\n");
    }
    pthread_exit(NULL);
}
void *thread_run2()
{
    usleep(10000);
    {
        int ret;
        cpu_set_t get_cpus;
        CPU_ZERO(&get_cpus);
        ret = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &get_cpus);
        if (ret < 0)
        {
            perror("faild sched_getaffinity");
        }
        printf("pthread_run2[%ld] is running in processor:", pthread_self());
        for (int i = 0; i < 4; i++)
        {
            if (CPU_ISSET(i, &get_cpus))
            {
                printf("%d ", i);
            }
        }
        printf("\n");
    }
    int policy;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    while (1)
    {
        //usleep(10000);
        //printf("pthtrad_run2 on cpu[%d] policy = %d ,param.__sched_priority = %d!\n", sched_getcpu(),policy,param.__sched_priority );
        printf_str("thread_run2 is running!\n");
    }
    pthread_exit(NULL);
}
void *thread_run3()
{
   
    int policy;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);
    while (1)
    {
        //usleep(10000);
        //printf("pthtrad_run3 on cpu[%d] policy = %d ,param.__sched_priority = %d!\n", sched_getcpu(),policy,param.__sched_priority );
        printf_str("thread_run3 is running!\n");
    }
    pthread_exit(NULL);
}
int main(int argc, char const *argv[])
{
    pthread_t th1, th2, th3;

    pthread_attr_t attr;
    struct sched_param sched;
    int ret;
    int cpu_arr1[1] = {0};
    cpu_set_t mask1;
    sched.__sched_priority = 99;
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); //要使优先级其作用必须要有这句话
    pthread_attr_setschedpolicy(&attr, SCHED_RR);                //改变线程调度策略
    pthread_attr_setschedparam(&attr, &sched);                   //设置线程优先级
    ret = create_pthread(&th1, &attr, thread_run1, NULL, cpu_arr1,sizeof(cpu_arr1)/sizeof(cpu_arr1[0]));
    if (ret < 0)
    {
        printf("%s:%d:create_pthread1 fail\n", __FUNCTION__, __LINE__);
    }
    pthread_attr_destroy(&attr);

    int cpu_arr2[1] = {0};
    cpu_set_t mask2;
    sched.__sched_priority = 50;
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); //要使优先级其作用必须要有这句话
    pthread_attr_setschedpolicy(&attr, SCHED_RR);                //改变线程调度策略
    pthread_attr_setschedparam(&attr, &sched);                   //设置线程优先级
    ret = create_pthread(&th2, &attr, thread_run2, NULL, cpu_arr2,sizeof(cpu_arr2)/sizeof(cpu_arr2[0]));
    if (ret < 0)
    {
        printf("%s:%d:create_pthread2 fail\n", __FUNCTION__, __LINE__);
    }
    pthread_attr_destroy(&attr);

    int cpu_arr3[1] = {0};
    cpu_set_t mask3;
    sched.__sched_priority = 1;
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); //要使优先级其作用必须要有这句话
    pthread_attr_setschedpolicy(&attr, SCHED_RR);                //改变线程调度策略
    pthread_attr_setschedparam(&attr, &sched);                   //设置线程优先级
    ret = create_pthread(&th3, &attr, thread_run3, NULL, cpu_arr3,sizeof(cpu_arr3)/sizeof(cpu_arr3[0]));
    if (ret < 0)
    {
        printf("%s:%d:create_pthread3 fail\n", __FUNCTION__, __LINE__);
    }
    pthread_attr_destroy(&attr);

    pthread_join(th1, NULL);
    pthread_join(th2, NULL);
    pthread_join(th3, NULL);

    return 0;
}

#endif
卑微小丁
关注
专栏目录
Linux 编程之进程篇：调度、优先级、亲和性和资源限制
张拭心的博客 shixinzhang
03-13 6812
处理器在调度不同进程时，有什么策略。我们开发者可以如何影响处理器的调度。 文章目录进程的调度进程资源的限制Thanks 进程的调度 调度策略 影响调度的因素 优先级 CPU 亲和性 延伸：实时系统 内核调度的对象是线程，而不是进程？ 优先级 setpriority(PRIO_PROCESS, tid, ANDROID_PRIORITY_DISPLAY); [-19, 20) /* ** Keep in sync with android.os.Process.java ** This map
在 Linux 中，要让某一个线程或进程排他性地独占一个 CPU
最新发布
MusicScore的博客
09-30 361
为了隔离某个 CPU，不让中断占用这个 CPU，可以通过如下步骤手动将中断绑定到其他 CPU。通过这些配置，可以在 Linux 系统中实现一个线程排他性独占 CPU，避免几乎所有其他任务和中断的干扰，从而达到最低的延迟抖动。为此，Linux 提供了将中断绑定到特定 CPU 的能力，避免中断影响线程独占的 CPU 核。CPU 亲和性是指将一个线程绑定到特定的 CPU 核上运行，从而避免线程在多个 CPU 上调度引起的上下文切换。，使得空闲 CPU 不产生定时器中断，从而在任务独占的情况下减少中断。
C++线程调度策略
实践求真知
04-06 2953
一点睛 Linux调度策略可以分为3种 1SCHED_OTHER：表示分时调度策略（也称轮转策略），是一种非实时调度策略，系统会为每一个线程分配一段运行时间，称为时间片。 2SCHED_FILO：先来先服务策略，支持优先级抢占。CPU让一个先来的线程执行完再调度下一个线程，顺序就是按照创建线程的先后。线程一旦占用CPU就会一直运行，直到有更高级的任务达到或自己放弃CPU。 3SCH...
CPU亲和性设置 代码示例 sched_setaffinity sched_getaffinity
爱串门的小马驹博客
09-07 1022
来优化GPU和CPU间的通信路径。NCCL通信时也用到亲和性设置，来优化GPU和CPU间的通信路径。CPU亲和性（CPU Affinity）设置是操作系统中一个重要的性能优化手段，它允许程序或进程被绑定到特定的CPU核心上运行。这样做的好处包括减少缓存未命中、降低线程迁移（context switching）的开销，以及提高缓存的局部性（cache locality），从而可能提升程序的整体性能。对于我们NCCL集合通信，也用到亲和性设置，通过将需要与GPU交互的CPU设置为距离近的CPU核心，
Linux 性能调优之 CPU 亲和性配置
伤心的辣条
05-14 982
在大多数情况下，操作系统内核会自动决定将进程调度到哪个 CPU 或内核上运行，并且会多次对进程进行 CPU 调度。这意味着一个进程可能会在不同的 CPU 或内核上交替运行，并且可以利用系统中所有可用的 CPU 资源。通常情况下，这种自动调度对系统运行是没有问题的。
管理处理器的亲和性（affinity）
康林工作室
07-14 1382
原文：http://www.ibm.com/developerworks/cn/linux/l-affinity.html 了解 Linux® 2.6 调度器如何处理 CPU 亲和性（affinity）可以帮助您更好地设计用户空间的应用程序。软亲和性（affinity） 意味着进程并不会在处理器之间频繁迁移，而 硬亲和性（affinity） 则意味着进程需要在您指定的处理器上运行。本文
线程设置CPU亲和性demo
sf_jiang的博客
10-20 871
#define _GNU_SOURCE 1 #include<stdio.h> #include<stdlib.h> #include<unistd.h> #include<pthread.h> #include<time.h> #include<sched.h> #include<string.h> void* testfunc(void* t) { int c = 0; c = sched_getcpu()..
linux 线程设置cpu亲和
jiangliuhuan123的博客
03-04 604
linux 线程设置cpu亲和
Linux进程调度详解：策略与优先级设置
5. `sched_setaffinity`：设置进程的CPU亲和性，决定进程可以在哪些CPU上运行。 进程调度有多种算法，如： 1. 先进先出（FIFO）：按照进程到达的顺序分配CPU。 2. 短进程优先（SPN）：优先执行预计运行时间较短的...
浅谈Windows 上的线程亲和性(Thread affinity)
0x0007 的博客
05-08 2674
由浅入深，从不同系统、C++语言、Windows对资源调度管理等多个层面阐述了线程亲和性的由来、使用，并附带了Raymond Chen的《Thread affinity of user interface objects》系列的翻译。
Linux 操作系统原理 — 进程管理 — NUMA 架构中的多线程调度开销与性能优化
烟云的计算
02-18 1667
NOTE：本文中所指 “线程” 均为可执行调度单元 Kernel Thread。
Linux内核：进程管理——CPU亲和力设置
m0_74282605的博客
04-12 703
指的是在多 CPU 的系统中将进程或线程绑定到指定的 CPU 核上去执行。在 Linux 中，我们可以利用 CPU affinity（亲和性） 属性把进程绑定到一个或多个 CPU 核上。以下函数根据不同进程调用时输入的不同数值，将不同进程绑定到不同的核，从而将 CPU 的多核心利用起来。是进程的一个属性，这个属性指明了进程调度器能够把这个进程调度到哪些CPU上。只是一个建议，如果不可避免，调度器还是会把进程调度到其它的CPU上去执行；如果调用成功，该函数返回一个非负的 CPU 编号值。
linux设置CPU亲和力,如何设置特定pthread的CPU亲和力？
weixin_36328790的博客
05-12 352
//compilation: gcc -o affinity affinity.c -lpthread#define _GNU_SOURCE#include //cpu_set_t , CPU_SET#include //pthread_t#include void *th_func(void * arg);int main(void) {pthread_t thread; //the t...
Linux中CPU亲和性(affinity)
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
11-21 3661
就是利用特殊的硬件指令，（一个核模拟出两个核？）让，进而兼容多线程操作系统和软件，减少了CPU的闲置时间，提高的CPU的运行效率。我们常听到的双核四线程/四核八线程指的就是支持超线程技术的CPU.**物理CPU:**机器上安装的实际CPU, 比如说你的主板上安装了一个8核CPU,那么物理CPU个数就是1个,所以物理CPU个数就是主板上安装的CPU个数。**逻辑CPU:**一般情况，我们认为一颗CPU可以有多核，加上intel的超线程技术(HT), 可以在逻辑上再分一倍数量的CPU core出来；
Linux 性能调优之CPU时间分布(亲和性、带宽、权重)配置Demo
伤心的辣条
05-18 1070
考试整理，分享一些Linux CPU时间分布配置的笔记 内容涉及 CPU 带宽，权重，亲和性配置前后测试Demo Deom 主要以进程级别使用 Cgroup-v2实现 服务级别 使用 systyemd 简单介绍 理解不足小伙伴帮忙指正 :) 生活加油
Linux 线程调度与优先级设置
weixin_34088583的博客
01-15 435
转载：http://blog.csdn.net/a_ran/article/details/43759729 　　 线程调度间的上下文切换 什么是上下文切换？ 如果主线程是唯一的线程，那么他基本上不会被调度出去。另一方面，如果可运行的线程数大于CPU的数量，那么操作系统最终会将某个正在运行的线程调度出去，从而 使其他线程能够使用CPU。这将导致一次上下文切换。在这个过程中将保存当前运行线...
Linux线程优先级
Peter的专栏
03-03 2322
Linux线程优先级范围 Linux定义线程优先级范围在头文件<linux/sched.h>/* *Priorityofaprocessgoesfrom0..M...
Linux 中查看进程的优先级
深耕嵌入式领用多年， 致力于分享嵌入式领域技术!
07-01 2125
Linux 中查看进程的优先级
linux服务器怎么降低内核cpu进程,Linux性能挖潜的隐藏招数:内核CPU亲和性参数调整...
weixin_32251525的博客
04-28 459
作者：李彬，赵雪枫，金融科技工程师，架构师社区特邀作者！应用服务性能调优，是每个系统投产前都需要关注的问题，系统及软件层面的调优方法均有大量文章介绍，但在所有招数使出后，是否就无潜可挖了？如果了解Linux内核运行特征，经过简单的配置，仍存在不少可行的方案。本文将介绍的是基于Linux内核CPU亲和性参数调整，榨取最后一丝性能优势的方案。一、背景知识CPU是常规应用运行计算的核心，从性能角度至少需...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值