Linux内核中线程的实现方式

最新推荐文章于 2023-05-27 20:52:33 发布
最新推荐文章于 2023-05-27 20:52:33 发布
阅读量797 收藏
点赞数
分类专栏： Kernel Linux 文章标签： Linux kernel Thread Implementation
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liqingxu2005/article/details/41246141
版权

摘要

本文通过对Linux内核源码的研究和两个C/C++程序，探讨了 Linux内核对线程的支持。并得出了一个结论：Linux内核的线程实现是货真价实的。因此，Linux上的多线程实现是真正的多线程实现。所谓Linux内核其实并不支持线程的说法是错误的。

1.    前言

关于Linux 内核中线程的实现方式，有一种说法认为：Linux内核其实并不支持线程，因此，Linux上的多线程实现其实是“伪多线程”。

这种说法到底正确吗？Linux内核到底是否支持多线程？本文作者通过对Linux内核源码的研究和一些C/C++程序来回答这一问题。

2.    进程与线程

按照操作系统教科书中的定义。进程与线程有以下特点：

1） 进程是程序的执行。

2） 在一个进程中，可以有一到多个线程。

3） 这些线程共享同一个地址空间。

4） 但是每个线程有自己独立的运行栈。

5） 每个线程可以被操作系统独立地调度。

3.    描述线程的数据结构

根据http://en.wikipedia.org/wiki/Multithreading_(computer_architecture),多线程编程模式兴起于90年代末。因此，当Linus Torvalds于1991年实现Linux的第一个版本是，他根本没有考虑对线程的支持。

在早期的Linux版本中，Linux只支持进程，不支持线程。在早期的Linux的版本中，描述进程的数据结构式struct task_struct，这也就是操作系统教科书中所说的PCB（Process Control Block）。

为了支持线程，当代Linux采用的方式是用struct task_struct既描述进程，也描述线程。图1给出了2.6.32.27内核中描述进程/线程关系的数据结构。

图1：描述进程/线程关系的数据结构

 

从上图我们可以看出：

1） 每个线程都用一个独立的task_struct来描述。

2） 同一个进程的多个线程通过task_struct的thread_group指针字段链接成一个双向循环链表。为了清晰起见，上图只是画出了一个方向的链接。

3） 同一个进程的多个线程共享同一个内存地址空间，因为它们task_struct的mm指针字段都指向了同一个mm_struct结构。

4） 对于每个信号，同一个进程的多个线程共享同一个信号处理程序。因为它们task_struct的sighand字段都指向了同一个sighand_struct结构。

5） 同一个进程的多个线程共享同一个文件描述表。因此，一个线程打开的文件，对其它线程也是可见的。

 

 

为了验证上面的结论，我们下面通过一个用户态的多线程程序和一个内核态的模块来进行验证。本文的实验环境如下：

1） Cent OS 版本: 6.5

2） Linux内核2.6.32

3） GCC版本：4.4.7

4.    一个用户态的多线程程序

下面是该用户态程序的源码：

#include <stdio.h>

#include <unistd.h>

#include <pthread.h>

#include <signal.h>

 

static void handler(int sig)

{

   printf("CTRL+C captured\n");

}

static void *threadFunc(void *arg)

{

   printf("In threadFunc()\n");

 

   int fd = dup(0);

 

   printf("fd = %d\n", fd);

 

   struct sigaction sa;

   sigemptyset(&sa.sa_mask);

   sa.sa_flags = 0;

   sa.sa_handler = handler;

   if (sigaction(SIGINT, &sa, NULL) == -1)

   {

       printf("Set SIGINT handler error\n");

   }

 

   sleep(60 * 10); // in seconds

 

   return (void *)1;

}

 

int main(void)

{  

   pthread_t t[100];

   void *res;

   int s;

   int thread_count = 2;

   int i;

 

   for (i=0; i<thread_count; i++)

   {

       s = pthread_create(&t[i], NULL, threadFunc, NULL);

 

       if (s != 0)

           printf("pthread_create() call failed. Return value:%d.\n", s);

   }

 

   for (i=0; i<thread_count; i++)

   {

       s = pthread_join(t[i], &res);

       if (s != 0) {

           printf("pthread_join() call failed. Return value: %d\n", s);

       }

       else {

           printf("pthread_join() call suceeded. Thread exit code: %ld\n", (long)res);

       }

 

   }

 

   return 0;

}

 

下面是编译该程序的Makefile：

TARGET = pthread_test

SOURCES = main.cpp

CC = g++

FLAGS = -g -Wall

LIBS = -lm -lstdc++ -pthread

 

 

# Objs are all the sources, with .cpp replaced by .o

OBJS := $(SOURCES:.cpp=.o)

all: $(TARGET)

$(TARGET): $(OBJS)

               $(CC) $(CFLAGS) -o $(TARGET) $(OBJS) $(FLAGS) $(LIBS)

 

.cpp.o:

               $(CC) $(FLAGS) $(INCLUDES) -c $<

clean:

               rm -f *.o

               rm -f $(TARGET)

 

该用户态程序在主线程中通过POSIX Thread库创建了两个线程。在每个线程中：

1） 调用dup(0)复制一个新的标准输入的描述符。

2） 设置了SIGINT信号的处理程序。

3） 睡眠一个小时。

5.    一个内核态的模块

该内核态模块的源码：

#include <linux/module.h>   // included for all kernel modules

#include <linux/kernel.h>   // included for KERN_INFO

#include <linux/init.h>     // included for __init and __exit macros

#include <linux/sched.h>

#include <linux/fdtable.h>

 

 

MODULE_LICENSE("GPL");

 

void dump_schedule_info(struct task_struct *task)

{

   printk("sched_class of task id(%d, comm='%s'):0x%x\n", task->pid, task->comm, task->sched_class);

}

 

void dump_file_struct(struct files_struct *files)

{

   int max_fds = files->fdt->max_fds;

   int fd;

 

   printk("files->fdt->max_fds=%d\n", max_fds);

   for (fd=0;fd<max_fds;fd++)

   {

       if (FD_ISSET(fd, files->fdt->open_fds))

       {

           printk("fd %d is open\n", fd);

       } // if

   } // for

}

 

void dump_sighand_struct(struct sighand_struct *sighand)

{

   int i;

 

   for (i=0; i<_NSIG; i++)

   {

      struct k_sigaction *sigaction = &sighand->action[i];

      if (sigaction->sa.sa_handler == SIG_DFL)

      {

          printk("SIG %d: SIG_DFL\n", i);

      }

      else if (sigaction->sa.sa_handler == SIG_IGN)

      {

          printk("SIG %d: SIG_IGN\n", i);

      }

      else

      {

          printk("SIG %d: 0x%x\n", i, sigaction->sa.sa_handler);

      }

 

 

   } // for

}

 

void enum_threads_in_process(struct task_struct *proc)

{

   struct task_struct *t;

 

   printk("Start enumerating threads in process:%d\n", proc->pid);

 

   int count = 0;

 

   t = proc;

 

   do

   {

       printk("Thread id=%d, comm='%s', files=0x%x, mm=0x%x, active_mm=0x%x, sighand=0x%x\n", t->pid, t->comm, t->files, t->mm, t->active_mm, t->sighand);

       dump_schedule_info(t);

       dump_file_struct(t->files);

       dump_sighand_struct(t->sighand);

       count ++;

 

       t = next_thread(t);

   } while (t != proc);

 

   printk("Thread count in proc(pid=%d):%d\n", proc->pid, count);

}

 

void enum_processes()

{

   struct task_struct *proc;

 

   printk("\n\nStart enumerating processes:\n");

 

   int count = 0;

 

   for_each_process(proc)

   {

      printk("pid=%d, comm='%s', files=0x%x\n", proc->pid, proc->comm, proc->files);

      enum_threads_in_process(proc);

      printk("\n");

      count ++;

   } // for_each_process

 

   printk("Process count:%d\n", count);

}

 

int init_module(void)

{

   enum_processes();

   return 0;    // Non-zero return means that the module couldn't be loaded.

}

 

void cleanup_module(void)

{

   printk(KERN_INFO "Cleaning up module.\n");

}

 

下面是编译该模块的Makefile：

obj-m += enum_processes.o

all:

               make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:

               make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

 

在内核加载该内核态模块时，该模块：

1） 枚举出系统中的每一个进程。

2） 对于每个进程，枚举出其每一个线程。

3） 对于每个线程，打印其task_struct的mm指针字段。

4） 对于每个线程，打印其文件描述符表。

5） 对于每个线程，打印其每个信号的处理程序。

6.    实验

6.1  运行用户态程序pthread_test

我们运行pthread_test，然后按CTRL+C。

[liqingxu@localhost posix_thread]$ ./pthread_test

In threadFunc()

fd = 3

In threadFunc()

fd = 4

^CCTRL+C captured

 

通过上面的输出，我们可以看到：

1） 线程成功的设置了SIGINT信号的处理程序。

2） 第一个线程的dup(0)调用返回的文件描述符为3。

3） 第二个线程的dup(0)调用返回的文件描述符为4。

 

 

6.2  安装内核态模块enum_processes.ko

安装下面的步骤，安装内核态模块enum_processes.ko。

1） 切换到root用户。

2） 然后运行tail –f /var/log/messages，以显示该模块注册时打印的信息。

3） insmod enum_processes.ko。

 

下面是该模块注册时打印的一部分信息。通过下面highlight出的信息，我们可以看出：

1） 每个线程都共享同一个地址空间，因为其task_struct 的mm字段指向了同样的mm_struct结构。

2） 每个线程都共享同一个信号处理程序。因为它们task_struct的sighand字段都指向了同一个sighand_struct结构。

3） 每个线程都共享同一个文件描述表。

这验证了我们前面讨论描述线程的数据结构时得到的结论。

Nov 10 03:43:30 localhost kernel: pid=5703, comm='pthread_test', files=0x4f12b200

Nov 10 03:43:30 localhost kernel: Start enumerating threads in process:5703

Nov 10 03:43:30 localhost kernel: Thread id=5703, comm='pthread_test', files=0x4f12b200,mm=0x4f00c180, active_mm=0x4f00c180, sighand=0x6462b540

Nov 10 03:43:30 localhost kernel: sched_class of task id(5703, comm='pthread_test'):0x8160be60

Nov 10 03:43:30 localhost kernel: files->fdt->max_fds=256

Nov 10 03:43:30 localhost kernel: fd 0 is open

Nov 10 03:43:30 localhost kernel: fd 1 is open

Nov 10 03:43:30 localhost kernel: fd 2 is open

Nov 10 03:43:30 localhost kernel: fd 3 is open

Nov 10 03:43:30 localhost kernel: fd 4 is open

Nov 10 03:43:30 localhost kernel: SIG 0: SIG_DFL

Nov 10 03:43:30 localhost kernel: SIG 1: 0x4007e4

Nov 10 03:43:30 localhost kernel: SIG 2: SIG_DFL

......

Nov 10 03:43:30 localhost kernel: Thread id=5704, comm='pthread_test', files=0x4f12b200,mm=0x4f00c180, active_mm=0x4f00c180, sighand=0x6462b540

Nov 10 03:43:30 localhost kernel: sched_class of task id(5704, comm='pthread_test'):0x8160be60

Nov 10 03:43:30 localhost kernel: files->fdt->max_fds=256

Nov 10 03:43:30 localhost kernel: fd 0 is open

Nov 10 03:43:30 localhost kernel: fd 1 is open

Nov 10 03:43:30 localhost kernel: fd 2 is open

Nov 10 03:43:30 localhost kernel: fd 3 is open

Nov 10 03:43:30 localhost kernel: fd 4 is open

Nov 10 03:43:30 localhost kernel: SIG 0: SIG_DFL

Nov 10 03:43:30 localhost kernel: SIG 1: 0x4007e4

Nov 10 03:43:30 localhost kernel: SIG 2: SIG_DFL

......

Nov 10 03:43:30 localhost kernel: Thread id=5705, comm='pthread_test', files=0x4f12b200,mm=0x4f00c180, active_mm=0x4f00c180, sighand=0x6462b540

Nov 10 03:43:30 localhost kernel: sched_class of task id(5705, comm='pthread_test'):0x8160be60

Nov 10 03:43:30 localhost kernel: files->fdt->max_fds=256

Nov 10 03:43:30 localhost kernel: fd 0 is open

Nov 10 03:43:30 localhost kernel: fd 1 is open

Nov 10 03:43:30 localhost kernel: fd 2 is open

Nov 10 03:43:30 localhost kernel: fd 3 is open

Nov 10 03:43:30 localhost kernel: fd 4 is open

Nov 10 03:43:30 localhost kernel: SIG 0: SIG_DFL

Nov 10 03:43:30 localhost kernel: SIG 1: 0x4007e4

Nov 10 03:43:30 localhost kernel: SIG 2: SIG_DFL

......

Nov 10 03:43:30 localhost kernel: Thread count in proc(pid=5703):3

7.    PThread线程库是如何创建线程的

7.1  Glibc源程序RPM包的下载

 Pthread library的实现在glibc中。

wget http://vault.centos.org/6.5/os/Source/SPackages/glibc-2.12-1.132.el6.src.rpm

7.2  从RPM包中获取Glibc的源码

1)      需要先安装rpm-build包

yum install rpm-build

2)      mkdir -p ~/rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}

3)      编译但编译完成后不删除源程序

rpmbuild --recompile glibc-2.12-1.132.el6.src.rpm

4)      编译完成后，Pthread的源程序在~/rpmbuild/BUILD/glibc-2.12-2-gc4ccff1/nptl目录下

7.3  pthread_create()的实现

Linux内核提供了一个系统调用clone()可以创建线程。该系统调用的实现函数是sys_clone()。

在文件nptl/sysdeps/pthread/createthread.c中，我们可以看到传递给clone()系统调用的flags参数如下：

 int clone_flags = (CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGNAL

                                    | CLONE_SETTLS | CLONE_PARENT_SETTID

                                    | CLONE_CHILD_CLEARTID | CLONE_SYSVSEM

#if __ASSUME_NO_CLONE_DETACHED == 0

                                    | CLONE_DETACHED

#endif

                                    | 0);

我们可以看出，因为pthread_create()传递给sys_clone()的flags参数中包含了CLONE_VM |  CLONE_FILES | CLONE_SIGNAL标志，所以其创建出来的线程都共享一个地址空间、一套文件描述符表和一套信号处理程序表。

8.    结论

通过前面对Linux内核源码的分析和实验，我们可以得出来一个结论：Linux内核的线程实现是货真价实的。因此，Linux上的多线程实现是真正的多线程实现。

9.    参考资料

1.       Daniel P. Bovet & Marco Cesati著.  Uderstanding the Linux Kernel. O’Reilly Media, Inc. 2006.

2.       Michael KerrisK. The Linux Programming Interface. No Starch Press, Inc. 2010.

Syscalls on x86/x64: http://stackoverflow.com/questions/9506353/how-to-invoke-a-system-call-via-sysenter-in-inline-assembly-x86-amd64-linux
老硕士
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux内核线程编程方法
07-29
Linux内核线程编程涉及到操作系统的核心机制，是Linux系统中用于执行特定内核任务的一种机制。内核线程与用户进程的主要区别在于它们不拥有独立的地址空间，它们的活动范围仅限于内核空间，不会进行用户态到内核态的...
多线程(如何理解pthread库)
最新发布
m0_72873854的博客
10-03 402
多线程(如何理解pthread库)
13 Day：实现内核线程
GeniusLS的博客
02-11 849
线程线程线程，编写操作系统线程
操作系统(2.8)--线程的实现
码银的博客
05-27 1488
在组合方式线程系统中，内核支持多KST线程的建立、调度和管理，同时，也允许用户应用程序建立、调度和管理用户级线程。由LWP实现了在内核与用户级线程之间的隔离，从而使用户级线程与内核无关。运行时系统所谓“运行时系统”，实质上是用于管理和控制线程的函数（过程)的集合，其中包括用于创建和撤消线程的函数、线程同步和通信的函数以及实现线程调度的函数等。内核支持线程，与进程相同，是在内核的支持下运行的，即无论是用户进程中的线程，还是系统进程中的线程，他们的创建、撤消和切换等也是依靠内核，在内核空间实现的。
Linux下面signal处理
dayenglish的专栏
04-21 694
信号也被称为软中断，主要用于在软件层面对中断机制的一种模拟。在所有的进程通信当中只有信号是异步的，接受信号的进程不知道什么时候信号会来，也不知道来的是什么信号。我们可以通过在控制台执行kill -l命令查看所有的信号变量。每一个信号在进程调度并由内核空间返回到用户空间的时候进行处理，在处理完信号之后，又需要返回到内核然后再进入到用户空间执行。至于为什么会这样会在下面的分析中看到原因。 在stru
Linux18 ---进程和线程、线程实现方法、线程的使用接口、多线程代码实现、线程并发运行
kyrie_sakura的博客
11-18 484
进程和线程 线程实现方法 线程的使用接口 多线程代码实现 线程并发运行
linux2.6.1内核源码注释
03-10
在Linux内核中，常见的同步原语包括自旋锁（spinlock）、读写锁（rwlock）、信号量（semaphore）和完成标志（completion）。自旋锁用于保护短时间的临界区，防止其他CPU核同时访问；读写锁则允许同时有多个读取者但...
linux内核设计与实现3
04-20
《Linux内核设计与实现》第三版是一本深入解析Linux操作系统内核的权威书籍，对于想要深入了解Linux系统底层工作原理的初学者来说，是不可多得的参考资料。这本书全面覆盖了Linux内核的设计哲学、核心架构以及关键...
linux 内核设计艺术和实现
12-25
《Linux内核设计艺术》和《Linux内核设计与实现（原书第3版）》这两本书是Linux内核开发者的必备读物，它们深入浅出地探讨了Linux内核的设计理念、架构以及具体实现。这里，我们将围绕这些书籍中的核心知识点进行...
Linux内核设计与实现(第三版中文高清带目录)
03-02
内存管理中，Linux内核使用了虚拟内存系统，通过页表映射物理内存，实现了地址空间的隔离和内存保护。在文件系统部分，Linux支持多种文件系统，如EXT4、XFS、Btrfs等，每种文件系统都有其特性和优化策略。 关于...
Linux线程与信号
QtHalcon
12-01 4186
1信号与线程的关系 POSIX标准对多线程情况下的信号机制提出了一些要求： 信号处理函数必须在多线程进程的所有线程之间共享， 但是每个线程要有自己的挂起信号集合和阻塞信号掩码。 POSIX函数kill/sigqueue必须面向进程， 而不是进程下的某个特定的线程。 每个发给多线程应用的信号仅递送给一个线程， 这个线程是由内核从不会阻塞该信号的线程中随意选出来的。 如果发送一个致命信号到...
线程是如何实现的？
Alkali!的博客
04-25 834
不论是进程还是线程，都必须直接或间接地取得内核的支持。由于内核支持线程可以直接利用系统调用为它服务，故线程的控制相当简单；而用户级线程必须借助于某种形式的中间系统的帮助方能取得内核的服务，故在对线程的控制上要稍复杂些。 1．内核支持线程的实现 在仅设置了内核支持线程的 OS 中，一种可能的线程控制方法是，系统在创建一个新进程时，便为它分配一个任务数据区 PTDA ( Per Task Data Area )，其中包括若干个线程控制块 TCB 空间，如图所示。 在每一个 TCB 中可保存线程标识符、优先级、
Linux signal 那些事儿 （3）
raidtest的专栏
10-24 714
Linux signal 那些事儿 （3） 2014-01-05 21:21:25 分类： LINUX     这篇博客，想集中在signal 与线程的关系上，顺带介绍内核signal相关的结构。如何组织我其实并没想好，想到哪就写到哪里吧。主题一定会落在signal之内而不跑题。     提到signal与thread的关系，就得先提POSIX标准。POSIX标准
浅谈Linux信号机制
Jogger_Ling的专栏
03-05 1321
信号在Linux系统中有广泛的应用，但信号机制不像消息队列、信号量那么直接明了，而是存在着较多的特殊逻辑。本文主要是分析信号的用户层接口在内核中是如何实现的，以及使用过程中需要注意的地方。如无特别说明，本文中内核代码的版本是2.6.32.27（展示代码有删减，只保留相关的部分），体系结构是IA-32。 1. 基础知识 这里不介绍信号的概念、作用和常用API等内容，只是描述一下内核中和信
内核级线程Linux实现
qq_37857224的博客
01-07 1564
内核在创建进程的时候,在创建 task_struct 的同时,会为进程创建相应的堆栈。每个进程会有两个栈,一个用户栈,存在于用户空间,一个内核栈,存在于内核空间。 当进程在用户空间运行时,cpu 堆栈指针寄存器里面的内容是用户堆栈地址,使用用户栈; 当进程在内核空间运行时,cpu 堆栈指针寄存器里面的内容是内核栈空间地址,使用内核栈。 当进程因为中断或者系统调用而陷入内核态之行时,进程所使用的堆栈也要从用户栈转到内核栈。 ...
linux模块编程（二）——运行不息的内核线程kthread
热门推荐
qb_2008的专栏
09-30 1万+
上节中，我们成功地编译运行了一个linux模块。可惜的是，它只有两个函数，hello_init在模块加载时调用，hello_exit 在模块卸载时调用。这样下去，模块纵使有天大的本事，也只能压缩在这两个函数中。为了避免这种悲剧发生，本节就来学习一种让模块在加载后能一直运行下去的方
线程的实现方式之内核支持线程和用户级线程
weixin_34218890的博客
05-21 1781
　　线程是OS进行独立调试、执行的基本单位，进程是系统进行资源分配的基本单位，一个进程可以包含若干个线程。无论是系统进程还是用户进程，进程的创建、撤消、以及要求系统设备完成的IO操作，都是利用系统调用而进入内核，再由内核中相应处理程序予以完成。进程的切换同样是在内核的支持下实现的。即不论什么样的进程，它们都是在OS内核的支持下运行的，是与内核紧密相关的。 1. 线程的分类 　　线程根据其实现方...
浅析Linux信号机制
Jogger_Ling的专栏
03-30 379
信号在Linux系统中有广泛的应用，但信号机制不像消息队列、信号量那么直接明了，而是存在着较多的特殊逻辑。本文主要是分析信号的用户层接口在内核中是如何实现的，以及使用过程中需要注意的地方。如无特别说明，本文中内核代码的版本是2.6.32.27（展示代码有删减，只保留相关的部分），体系结构是IA-32。 1.基础知识 这里不介绍信号的概念、作用和常用API等内容，只是描述一下内核中和信
linux中的内核模块
hqb_newfarmer的博客
03-06 225
linux中的内核模块
linux内核 多线程
08-12
在Linux内核中，可以通过内核线程（kernel thread）来实现多线程。内核线程是独立运行在内核空间的标准进程，与普通进程相比，内核线程没有独立的地址空间，mm指针被设置为NULL，只在内核空间运行，不切换到用户空间去。内核线程可以被调度和抢占。 在Linux内核中，可以使用kthread_run()函数来创建内核线程。这个函数接受一个执行函数和一个参数作为参数，可以在执行函数中完成一些后台任务。创建的内核线程可以通过kthread_stop()函数来停止。 在早期的Linux 2.6版本中，可以使用kernel_thread()函数来创建内核线程。但在较新的版本中已不推荐使用该方式，因为在4.1版本中不再使用export。使用kernel_thread()创建的非内核线程需要在其执行函数中调用daemonize()函数来释放资源。 除了以上两种方式，还可以使用kthread_create()函数来创建内核线程。这个函数与kthread_run()类似，用法也相似。 总之，在Linux内核中可以通过内核线程来实现多线程的功能，这些内核线程可以在后台执行一些任务，具有调度和抢占的特性。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Linux内核多线程](https://blog.csdn.net/Frank_sample/article/details/116455771)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值