【操作系统-线程池】Pthread 线程池的设计及实现

最新推荐文章于 2024-04-14 10:15:45 发布
最新推荐文章于 2024-04-14 10:15:45 发布
阅读量1.2k 收藏 9
点赞数 3
分类专栏： 基础知识 操作系统 笔记 文章标签： 面试 经验分享 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_52387305/article/details/124967321
版权

Lab Week 15 实验报告

实验内容：设计实现一个线程池 (Thread Pool)

  • 使用 Pthread API 管理线程。
  • 利用回调函数作为线程的启动函数。
  • 采用 pthread 信号量解决线程池分配的互斥问题。
  • 讨论上述方案的技术可行性，尝试写一个设计报告。
  • 在一个源代码文件内实现编码、完成编译、运行和用例测试。

I.线程池

线程池的提出，主要是为了解决：

（1）频繁地为某一任务创建和销毁线程所引起的系统资源耗费问题；

（2）无限制地为并发请求创建线程且系统对线程数量没有限制而引起的系统资源耗费问题；

线程池的主要思想是：在进程一开始启动时即创建一定数量空闲的线程，加入到线程池中等待工作。当任务传给线程池的时候，线程池会唤醒一个线程来执行这个任务，一旦线程完成任务，就会回到线程池中等待新的任务到来，如果线程池中没有空闲的线程，那么会等到有空闲线程为止。

线程池具有以下优点：

  1. 用现有线程服务请求比等待创建一个线程更快。
  2. 线程池限制了任何时候可用线程的数量。这对那些不能支持大量并发线程的系统非常重要。
  3. 将要执行任务从创建任务的机制中分离出来，允许我们采用不同策略运行任务。例如，任务可以被安排在某一个时间延迟后执行，或定期执行。

II.线程池设计

A. 线程池组成

（1）线程管理函数（ThreadPool）：用于创建线程池、销毁线程池、添加新任务；

（2）任务队列（TaskQueue）：用于管理任务的队列（FIFO），将新的任务加到队列尾部，即将执行的任务在队列头部；

（3）工作线程（Workers）：线程池中的线程，在任务到来时分配给工作线程，在没有任务时等待；

注意：在任务队列的部分，需要保证一个任务只能被一个线程取走，所以需要引入pthread 信号量以解决线程池分配的互斥问题；

image-20220525153358375

B. 设计思路：

(1)在主函数中调用线程池初始化函数，同时线程池中的线程执行线程函数，随后将任务添加到任务队列中；

(2)在线程函数中，每个线程对当前任务队列的状态进行判断，若不空，则取出任务执行，若为空则等待；

(3)待任务添加完且线程执行完所有任务后，对线程进行回收并销毁线程池及其他动态创建的堆栈和信号量；

(4)程序结束；

C.实现代码：

代码模块：

以下对线程池的实现根据不同功能相对应的模块进行说明：

任务结构和线程池结构

typedef struct
{
    void*(*func)(void*);
    void*args;
}threadpool_task;

struct threadpool
{
    threadpool_task* task_queue; // 任务队列
    sem_t unnamded_sem; //匿名信号量
    int front;
    int rear;
    int queue_size; //队列大小
    int thread_num;
    int count; //等待任务数
    pthread_t* ptid; //线程tid表
    int tasknum; //总的任务数
};

代码说明：

这部分定义了线程需要完成的任务和线程池的数据结构；

在任务结构中，定义了该任务对应的回调函数和相应的参数；

在线程池结构中，定义了任务队列和相应的控制变量、与任务相关的变量、解决线程池分配的互斥问题的匿名信号量；

线程池初始化函数

threadpool* threadpool_create(int thread_num, int queue_size, int task_num){
  /*
  	param: thread_num 线程数
  	param: queue_size 队列大小
  	param: task_num 任务数
  
  */
    int ret, i;
    if(thread_num > MAX_THREADS || queue_size > MAX_QUEUE){
        return NULL;
    }

    threadpool* pool;
    if((pool = (threadpool*)malloc(sizeof(threadpool))) == NULL){
        perror("threadpool:malloc()");
    }

    //Initialize thread pool
    pool->front = pool->rear = 0;
    pool->queue_size = queue_size;
    pool->thread_num = 0; 
    pool->tasknum = task_num;
  
    // Allocate thread and task queue
    pool->task_queue = (threadpool_task*)malloc(sizeof(threadpool_task)*queue_size);
    pool->ptid = (pthread_t*) malloc(sizeof(pthread_t)*thread_num);

    //Initialize unnamed semaphore
    ret = sem_init(&pool->unnamded_sem, 0, 1);
    if(ret == -1) {
        perror("sem_init()");
    }
    
    //Create threads
    for(i = 0; i<thread_num; i++){
        ret = pthread_create(&(pool->ptid[i]), NULL, &threadpool_exec, (void*)pool);
        if(ret != 0) {
            perror("producer pthread_create()");
            break;
        }
        pool->thread_num++; // 进入线程池的线程数加1
    }
     
    return pool;
}

代码说明：

这部分对线程池进行初始化，其中包括：

  • 用malloc进行动态分配：线程池，任务队列、线程号表；

  • 对匿名信号量进行初始化，sem_init(&pool->unnamded_sem, 0, 1) ，将信号量初始化为1，并限制在当前进程使用；

  • pthread_create(&(pool->ptid[i]), NULL, &threadpool_exec, (void*)pool) 创建线程，并调用函数threadpool_exec() ，传递的参数为线程池指针；

任务添加函数

void threadpool_add(threadpool * pool, void*(*func)(void*), void*args){
    /*
  	param: pool 线程池
  	param: func 任务函数
  	param: args 函数参数
  
  */
    while((pool->rear + 1) % pool->queue_size == pool->front){ // 当任务队列满的时候
        printf("Task queue is full, task No.%d waitting for handling\n", *(int*)args);
        sleep(1);
    }

    pool->task_queue[pool->rear].func = func;
    pool->task_queue[pool->rear].args = args;
    pool->rear = (pool->rear + 1) % pool->queue_size;
    pool->count += 1; //任务队列中的任务数加1

}

代码说明：

这部分主要负责向任务队列中添加函数，通过该函数传进来的任务函数和相应的参数，对线程池中的任务队列添加任务，并对控制变量进行修改；

线程执行函数

static void *threadpool_exec(void *arg){
    threadpool* pool = (threadpool*)arg;
    threadpool_task task;
    while(1){
        while(pool->front == pool->rear){ //当队列为空时
            if(!pool->tasknum){ // 如果所有任务都已经处理完毕，则退出线程
                printf("Thread %ld exits\n", gettid());
                pthread_exit(NULL);
            }
            printf("Thread %ld is waitting for new task\n", gettid()); //否则打印出线程等待的信息
            sleep(1);
        }
        if(pool->tasknum == 0){
            break;
        }
        //利用信号量保证一个线程只能处理一个任务
        sem_wait(&pool->unnamded_sem); //获得信号量

        //线程获得任务
        task.func = pool->task_queue[pool->front].func;
        task.args = pool->task_queue[pool->front].args;
        pool->front = (pool->front + 1) % pool->queue_size; 
        pool->count -= 1; //任务队列中的任务数减1
        pool->tasknum -= 1; // 总任务数减1
        sem_post(&pool->unnamded_sem); //释放信号量

        // Go to Work!!
        (*(task.func))(task.args);
    }
}

代码说明：

这部分代码为线程调用的函数，其中包括对线程池分配的互斥问题、线程获取任务、等待任务的处理；

  • 当队列为空时，如果所有任务执行完毕，则让线程退出，反之则打印出等待信息

  • 为了让一个线程只处理一个任务，这里用了Pthread信号量来解决线程池分配的互斥问题，通过 sem_wait(&pool->unnamded_sem)来获取信号量，随后从任务队列中获取任务，修改控制变量后，执行sem_post(&pool->unnamded_sem) 释放信号量，之后，再利用

    (*(task.func))(task.args)来调用任务函数；

任务函数

void* taskfun(void* arg){
    int* temp = (int*) arg;
    int task_sn = *temp;
    printf("Thread %ld is working on task No.%d\n", gettid(), task_sn);
    printf("---- Thread %ld working last for 2s -----\n", gettid());
    sleep(2);
    printf("\t\t  Task No.%d finished\n", task_sn);
    return 0;
}

代码说明：

这部分为任务具体需要实现的内容，在这里，打印出线程号和它所处理的任务的序列号（以函数形参方式传入），随后sleep 2s，这样能够模拟线程在调用该任务函数时处理的过程，最后打印出结束标志；

线程池销毁函数

void threadpool_destroy(threadpool* pool){
    free(pool->task_queue);
    free(pool->ptid);
    sem_destroy(&pool->unnamded_sem);
    free(pool);
}

代码说明：

这部分对动态创建的线程池、线程号表、线程池还有匿名信号量进行销毁。

主函数

int main(){
    int i, ret;
    int thread_num, queue_size, task_num;
    thread_num = MAX_THREADS;
    queue_size = MAX_QUEUE;
    task_num = MAX_TASKS;
    printf("------Thread pool parameters-------\n");
    printf("Number of thread: %d, Size of task queue: %d, Number of task: %d\n", thread_num, queue_size, task_num);
    sleep(1);
    
    threadpool* pool = threadpool_create(thread_num, queue_size, task_num);
    if(pool == NULL){
        perror("threadpool_create()");
    }
    sleep(2);  //进入休眠，同时测试线程是否会等待任务队列添加任务

    for(i=0; i < task_num; ++i){
        printf("Adding task No.%d\n",i);
        threadpool_add(pool, &taskfun, &i); //添加任务
        sleep(1);
    }


    for(int i=0;i<thread_num;i++){
        pthread_join(pool->ptid[i], NULL);
    }
    printf("Tasks Completed, starting destroy\n");
    threadpool_destroy(pool);
    printf("\n\tExit Successfully\n");
    exit(EXIT_SUCCESS);
}

代码说明：

这部分为代码的主函数部分，在一开始调用threadpool_create(thread_num, queue_size, task_num)对线程池进行初始化，创建相应大小的任务队列、线程数和任务数，此后休眠2s，这里为了测试线程是否会等待任务队列添加任务；

然后通过循环调用 threadpool_add(pool, &taskfun, &i)来向任务队列中添加任务，每隔1s添加一次任务；

完整代码：
#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/syscall.h>
#include<semaphore.h>
#include<unistd.h>

#define gettid() syscall(__NR_gettid)
#define MAX_THREADS 10
#define MAX_QUEUE 12
#define MAX_TASKS 20
typedef struct threadpool threadpool;
threadpool * threadpool_create(int thread_num, int queue_size, int task_num);
void threadpool_add(threadpool * pool, void*(*func)(void*), void*args);
static void *threadpool_exec(void *threadpool);


typedef struct
{
    void*(*func)(void*);
    void*args;
}threadpool_task;

struct threadpool
{
    threadpool_task* task_queue;
    sem_t unnamded_sem;
    int front;
    int rear;
    int queue_size;
    int thread_num;
    int count; //等待任务数
    pthread_t* ptid;
    int tasknum; //总的任务数
};

threadpool* threadpool_create(int thread_num, int queue_size, int task_num){
    int ret, i;
    if(thread_num > MAX_THREADS || queue_size > MAX_QUEUE){
        return NULL;
    }

    threadpool* pool;
    if((pool = (threadpool*)malloc(sizeof(threadpool))) == NULL){
        perror("threadpool:malloc()");
    }

    //Initialize thread pool
    pool->front = pool->rear = 0;
    pool->queue_size = queue_size;
    pool->thread_num = 0;
    pool->tasknum = task_num;
    // Allocate thread and task queue
    pool->task_queue = (threadpool_task*)malloc(sizeof(threadpool_task)*queue_size);
    pool->ptid = (pthread_t*) malloc(sizeof(pthread_t)*thread_num);

    //Initialize unnamed semaphore
    ret = sem_init(&pool->unnamded_sem, 0, 1);
    if(ret == -1) {
        perror("sem_init()");
    }
    
    //Create threads
    for(i = 0; i<thread_num; i++){
        ret = pthread_create(&(pool->ptid[i]), NULL, &threadpool_exec, (void*)pool);
        if(ret != 0) {
            perror("producer pthread_create()");
            break;
        }
        pool->thread_num++;
    }
     
    return pool;
}

static void *threadpool_exec(void *arg){
    threadpool* pool = (threadpool*)arg;
    threadpool_task task;
    while(1){
        // sem_wait(&pool->unnamded_sem);
        while(pool->front == pool->rear){
            if(!pool->tasknum){
                printf("Thread %ld exits\n", gettid());
                pthread_exit(NULL);
            }
            printf("Thread %ld is waitting for new task\n", gettid());
            sleep(1);
        }
        if(pool->tasknum == 0){
            break;
        }
        //利用信号量保证一个线程只能处理一个任务
        sem_wait(&pool->unnamded_sem);

        //线程获得任务
        task.func = pool->task_queue[pool->front].func;
        task.args = pool->task_queue[pool->front].args;
        pool->front = (pool->front + 1) % pool->queue_size;
        pool->count -= 1;
        pool->tasknum -= 1;
        sem_post(&pool->unnamded_sem);

        // Go to Work!!
        (*(task.func))(task.args);
    }
}

void* taskfun(void* arg){
    int* temp = (int*) arg;
    int task_sn = *temp;
    printf("Thread %ld is working on task No.%d\n", gettid(), task_sn);
    printf("---- Thread %ld working last for 2s -----\n", gettid());
    sleep(2);
    printf("\t\t  Task No.%d finished\n", task_sn);
    return 0;
}

void threadpool_add(threadpool * pool, void*(*func)(void*), void*args){
    while((pool->rear + 1) % pool->queue_size == pool->front){ // 当任务队列满的时候
        printf("Task queue is full, task No.%d waitting for handling\n", *(int*)args);
        sleep(1);
    }

    pool->task_queue[pool->rear].func = func;
    pool->task_queue[pool->rear].args = args;
    pool->rear = (pool->rear + 1) % pool->queue_size;
    pool->count += 1;

}


void threadpool_destroy(threadpool* pool){
    free(pool->task_queue);
    free(pool->ptid);
    sem_destroy(&pool->unnamded_sem);
}

int main(){
    int i, ret;
    int thread_num, queue_size, task_num;
    thread_num = MAX_THREADS;
    queue_size = MAX_QUEUE;
    task_num = MAX_TASKS;
    printf("------Thread pool parameters-------\n");
    printf("Number of thread: %d, Size of task queue: %d, Number of task: %d\n", thread_num, queue_size, task_num);
    sleep(1);
    
    threadpool* pool = threadpool_create(thread_num, queue_size, task_num);
    if(pool == NULL){
        perror("threadpool_create()");
    }
    sleep(2);  //进入休眠，同时测试线程是否会等待任务队列添加任务

    for(i=0; i < task_num; ++i){
        printf("Adding task No.%d\n",i);
        threadpool_add(pool, &taskfun, &i); //添加任务
        sleep(1);
    }


    for(int i=0;i<thread_num;i++){
        pthread_join(pool->ptid[i], NULL);
    }
    printf("Tasks Completed, starting destroy\n");
    threadpool_destroy(pool);
    printf("\n\tExit Successfully\n");
    exit(EXIT_SUCCESS);
}

D.实验结果：

初始阶段：

在线程池中初始化10个线程，任务队列的大小为12，需要完成的总任务数为20；

image-20220525130537822

在一开始，由于是先对线程池进行初始化，在sleep 2s之后才向任务队列中添加任务，红框的部分为线程池中的线程在等待任务时打印出来的信息，如：Thread 28389 is waitting for new task，表示线程号为28389的线程正在线程池中等待系统分配给它任务；

工作阶段：

此时开始向任务队列中添加任务，任务以序列号标识，No.0表示序列号为0的任务：

image-20220525130630138

在添加完任务No.0之后，线程号为28394的线程首先接手这个任务，完成这个任务需要费时2s，由于任务1s才添加一个，所以在这期间线程需要等待，随后任务No.1进入任务队列，线程号为28392的线程接手这个任务，之后任务No.0被线程28394完成，它又重新回到线程池中等待任务，随后任务No.2进入任务队列，线程号为28397的线程接手这个任务，任务No.1被线程28392完成；

image-20220525130706962

注意到，在添加完任务No.6之后，线程号为28394的线程接手这个任务，该线程在之前曾接手过任务No.0；任务No.5也相继完成。

在添加完No.7的任务之后，线程号为28398的线程接手这个任务；

image-20220525130735324

在添加完任务No.17之后，线程号为28398的线程接手这个任务，该线程在之前曾接手过任务No.7；

线程28398执行完任务No.19之后，所有任务执行完毕，所有线程开始退出，最后调用销毁函数，线程池销毁，程序结束。

【源码剖析】threadpool —— 基于 pthread 实现的简单线程池
Just Coding！
12-24 1万+
介绍一个基于 pthread 的简单线程池的实现。
chromium线程模型(2)-线程池实现
woai110120130的专栏
10-19 883
到这里，除了关闭的情景，线程池的方方面面也分析的差不多了。我觉得chromium的设计实在是太复杂，存在过度设计嫌疑。另外如果有协程就不必这么大费周折的去处理阻塞任务。也许是因为开发者对底层不太了解，也可能是很多历史包袱，才使得chromium的设计如此复杂吧。
Linux pthread 线程池实现
aihongzang7880的博客
05-16 274
　　基于pthread封装了一个简易的ThreadPool,具有以下特性： 　　1.具有优先级的任务队列 　　2.线程池大小可以二次调整，增加线程或者删除空闲线程 　　3.任务两种重写方式，重写run或者使用函数回调 首先是任务类的声明 class Task{ public: string taskName; public: Task(){...
Linux pthread 实现线程池学习
chengwang2012的博客
12-01 214
C++ 线程池
浅谈线程池（下）：相关试验及注意事项
weixin_34223655的博客
10-20 150
三个月，整整三个月了，我忽然发现我还有三个月前的一个小系列的文章没有结束，我还欠一个试验！线程池是.NET中的重要组件，几乎所有的异步功能依赖于线程池。之前我们讨论了线程池的作用、独立线程池的存在意义，以及对CLR线程池和IO线程池进行了一定说明。不过这些说明可能有些“抽象”，于是我们还是要通过试验来“验证”这些说明。此外，我认为针对某个“猜想”来设计一些试验进行验证是非常重要的能力，如果您这方面...
线程池精讲（pthread pool）
qq_38769551的博客
09-25 1431
线程池也是多线程的处理方式。是将“生产者”线程提出任务添加到“任务队列”，然后一些线程自动完成“任务队列”上的任务。 多线程编程，创建一个线程，指定去完成某一个任务，等待线程的退出。虽然能够满足编程需求，但是当我们需要创建大量的线程的时候， 在创建过程以及销毁线程的过程中可能会消耗大量的CPU.增加很大开销。 如： 文件夹的copy WEB服务器的响应。 。。。。 。。。。 线程池就是用来解决类似于这样的一个问题的，可以降低频繁地创建和销毁线程所带来地开销。 线程池技术思路： 一般
Threadpool 轻量型 基于 pthread 实现的简单线程池 C语言
05-14
本项目是基于C语言实现的一个轻量级线程池，它利用了POSIX线程库（pthread）进行底层操作。 在C语言中，由于其本身并不内置多线程支持，因此需要借助第三方库，如pthread库，来实现多线程功能。pthread是POSIX标准...
用c实现的pthread线程池
07-27
pthread是UNIX和类UNIX操作系统中广泛使用的多线程API，它提供了一套丰富的函数来创建、同步和管理线程。线程池是基于pthread的一种高级抽象，它通过集中管理线程，避免了频繁创建和销毁线程的开销。 在C语言中实现...
基于liunx操作系统的线程池项目
09-03
本项目"基于Linux操作系统的线程池项目"是为初学者设计的，旨在帮助他们理解和实践线程池的概念，特别是如何利用pthread库进行线程管理和任务调度。 首先，我们来深入理解线程池的核心概念。线程池由一组工作线程...
【Linux操作系统】-- 多线程（三）-- 线程池+单例模式+读写者模型
qq_53413129的博客
09-02 854
线程池 场景 代码实现 线程安全的单例模式 懒汉实现方式和懒汉实现方式 饿汉方式实现单例模式 懒汉方式实现单例模式 实战代码演练单例模式 读者写者模型 解释 基本操作 创建/销毁读写锁 读者锁和写者锁 解锁 伪代码理解读写锁 优先级 挂起等待锁vs自旋锁 自旋锁语法
Pthread Pool:使用Pthreads实现的轻量级线程池-开源
04-25
Pthread池是一种轻量级，高效的线程池，完全使用Pthreads API实现。
Linux环境下用pthread库制作一个简单的线程池
zzzzzz_9的博客
12-04 1474
线程池提供了一种优化线程使用和管理的方式，它通过减少线程创建和销毁的开销、限制线程数量以及通过任务队列来调度任务等方式来提高系统的性能和资源利用率。并且通过合理配置线程池的线程数量，避免了过多的线程竞争，从而提高系统的响应速度和吞吐量。下面我写了一个范例，例如用线程池完成一份文件的读取的任务指针函数，到时候我们再主函数里面使用以上函数调用的时候以这个指针函数作为参数来实现对文件的读取。控制并发度：通过限制线程池中的线程数量，可以控制并发执行的任务数量，避免系统资源被过度占用。
c语言+pthread实现线程池
lazy_x的博客
10-24 4018
文章目录1.线程池原理2.项目结构项目源代码tpool.htpool.cdemo.c线程池完整源码见 1.线程池原理 线程池(thread pool)技术是指能够保证所创建的任一线程都处于繁忙状态，而不需要频繁地为了某一任务而创建和销毁线程，因为系统在创建和销毁线程时所耗费的cpu资源很大。如果任务很多，频率很高，为了单一一个任务而起线程而后销线程，那么这种情况效率相当低下的。线程池技术就是用于解决这样一种应用场景而应运而生的。 pthread线程池实现原理，首先创建多个线程组成线程池，其中每个线程都运行一
pthread
weixin_30502965的博客
07-09 113
pthread是UNIX操作系统中创建和控制线程的一系列API，通过了解这些API，可以更加清晰的理解线程究竟是什么。 调用pthread的API首先要包含<pthread.h>这一头文件，以下为pthread内的基础API。 1、pthread_create(创建线程) int pthread_create(pthread_t *restrict tidp, <span...
基于pthread实现的简单线程池模型
FintechBoy的博客
02-10 325
基于pthread实现的简单线程池模型，可实现线程池的创建、运行、终止、释放等操作。其主要API如下： // 创建线程池 int QtpThreadPoolCreate(struct QtpThreadPool** pool, int threadCnt); // 线程池销毁操作 int QtpThreadPoolDestroy(QtpThreadPool* pool); // 线程池任务调...
C设计实现一个线程池(thread pool)
weixin_44847746的博客
06-20 1402
C设计实现一个线程池环境思路代码main.cpool.cpool.h 环境 在ubuntu的linux操作系统下，使用C语言，使用pthread创建和管理线程。任务满足先进先出的原则，因此使用链表。 由于课程暂未学习到线程之间的互斥和锁的问题，所以不考虑线程的问题。 以链表的形式创建任务，导入线程池然后执行，再销毁线程池，即为实验的流程。 思路 下面开始讲解我关于线程池的构造。因为还没有学习到互斥锁的知识，所以暂时不考虑调用线程切换的时候可能出现的互斥问题。而是着重关心线程池中任务以及线程的构造。 对于任务
linux pthread 线程池,基于pthread的线程池，C++实现
weixin_42508905的博客
05-13 135
然后是比较关键的MyThreadPool类MyThreadPool.h#ifndef MYTHREADPOOL_H_#define MYTHREADPOOL_H_#include "MyWorkThread.h"#include "BaseJob.h"#include #include #include #include #include using namespace std;class MyT...
linux线程 -- 线程池
最新发布
sushhsishdgsusk的博客
04-14 1146
所谓的就是提前创建一批线程，可以提高整体效率；同时一批线程会被合理维护，避免调度时造成额外开销。
线程池初探(NTPL/pthread)
weixin_34344403的博客
05-13 192
　　最近计网课设选择了写一个ftp服务器，其中我想把服务器端写成多线程部分。由此接触了posix线程及其相关部分。相关阅读书籍：【1】现代操作系统 【2】posix多线程程序设计。 　　关于第二本是02年的，很久没出过新版了，NTPL与17年前的接口仍然大多一致，甚至是一样，由此引发了一些思考：现在那些花里胡哨的技术更新太快了，比如说java，c#，甚至c++每隔两年就要发布一个新的标准，然而这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值