Linux--进程控制

最新推荐文章于 2023-03-29 08:18:34 发布
最新推荐文章于 2023-03-29 08:18:34 发布
阅读量957 收藏
点赞数 1
分类专栏： Linux 文章标签： linux 数据结构 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiaoming1999/article/details/127928649
版权

目录

进程创建

fork函数初识

fork函数返回值 

写时拷贝

fork的常规用法

fork调用失败的原因

进程终止

进程退出场景

退出方法

①调用_exit函数 

②调用exit函数

③main函数return

④异常退出

 进程等待

进程等待的必要性

进程等待的方法

①wait方法

②waitpid方法

 获取子进程status

 阻塞、非阻塞代码实现

①阻塞等待方式

②进程的非阻塞等待方式 

 进程程序替换

替换原理

替换函数

①execl函数

②execlp函数 

③execle函数

④execv函数 

⑤execvp函数

⑥execve函数

函数解释

简易shell的实现 

进程创建

操作系统会做什么：

  • 创建大量内核数据结构对象、变量
  • 针对各种结构做初始化
  • 加载部分或全部程序对应的代码和数据
  • 建立映射关系
  • 将进程连入各种数据结构中

fork函数初识

  • 概念 

fork()函数，它是从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

  • 函数原型
#include <unistd.h>
pid_t fork(void);
  •  进程调用fork，当控制转移到内核中的fork代码后，内核做：
  1. 分配新的内存块和内核数据结构给子进程
  2. 将父进程部分数据结构内容拷贝至子进程
  3. 添加子进程到系统进程列表当中
  4. fork返回，开始调度器调度

如图： 

 当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。如下程序：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main()
{
        pid_t pid;
        printf("Before: pid id %d\n",getpid());

        pid = fork();
        if(pid == -1)
        {
                printf("出错了\n");
                exit(-1);
        }
        printf("After: pid is %d, fork return %d\n",getpid(),pid);

        sleep(1);
        return 0;

}

我们可以从输出的结果看到，在fork前的printf语句只执行了一次，fork后的printf语句打印了两次，可以看出94764为父进程，94765为子进程，也就是子进程没有打印fork前的printf语句。这是为什么呢？？？

所以，fork之前父进程独立执行，fork之后，父子两个执行流分别进行。

注意：fork之后，父子共享所有的代码,谁先执行完全由调度器决定。

子进程执行的后续代码 != 共享的所有代码，只不过是子进程只能从这里开始执行。 

fork函数返回值 

子进程中返回0，父进程中返回子进程的id，出错返回-1.

写时拷贝

  • 概念

通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。

  •  为什么要写时拷贝，创建子进程的时候就把数据分开不行吗？
  1. 父进程的数据，子进程不一定全用，即便使用也不一定全部写入，会有浪费空间的嫌疑
  2. 最理想的情况，只有会被父子修改的数据进行分离拷贝，不需要修改的共享即可（从技术角度实现复杂）
  3. 如果fork的时候，就无脑拷贝数据给子进程会增加fork的成本
  4. 所以最终采用写时拷贝：延迟拷贝策略，只有真正使用的时候才给你

fork的常规用法

fork函数不是为了创建子进程而创建子进程，它创建子进程的目的有两种：

  1. 一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如：父进程等待客户端请求，生成子进程来处理请求。
  2. 一个进程要执行一个不同的程序。例如：子进程从fork返回后，调用exec函数（做程序替换）

fork调用失败的原因

  1. 系统进程数达到太多，达到上限（系统会有一个进程数的限定，可以进行修改）
  2. 实际用户的进程数超过了限制 

进程终止

进程退出场景

  • 代码运行完毕，结果正确
  • 代码运行完毕，结果不正确
  • 代码没有运行完，异常终止

退出方法

  • 退出码 

程序在执行终止后传递值给其父进程，这个值被称为退出码（exit code）或退出状态（exit status）。当程序成功执行时传递 0 ，当程序执行失败时传递 1 或比 1 大的值。

在我们平时写的main函数的代码中，其实return 0的写法是不严谨的，main函数的return的结果就是其退出码。我们总是默认代码是正确的，没有根据执行结果返回相应的退出码。退出码可以自己定义也可以使用系统的错误码表。 

  • 查看退出码
echo $?

 

①调用_exit函数 

#include <unistd.h>
void _exit(int status);

status定义了父进程的终止状态，父进程通过wait来获取该值。

虽然status是int，但是仅有低8位可以被父进程所用，所以_exit(-1)时，在终端执行$?发现返回值是255。

如图： 

②调用exit函数

#include <unistd.h>
void exit(int status);

 _exit和exit区别：

  • _exit仅仅是直接终止进程，不会有任何刷新操作
  • exit在退出进程前，执行用户通过atexit或on_exit定义的清理函数，关闭所有打开的流，所有的缓冲数据均被写入，最后调用_exit.

 

 ③main函数return

return是一种更常见的退出进程方法。执行return n等同于执行exit(n)，因为调用main的运行时会将main的返回值当作exit的参数。

④异常退出

  1. 在进程运行过程中，使用kill -9信号使进程异常退出，或者使用ctrl+c迫使进程退出
  2. 代码异常使进程异常退出 

 进程等待

为什么要进行进程等待？

需要父进程回收子进程的僵尸进程，父进程要关心子进程的退出码。

进程等待的必要性

  • 子进程退出，父进程如果不管不顾，就可能造成僵尸进程的问题，进而造成内存泄漏。
  • 进程一旦变成僵尸进程，kill -9也不能将其杀掉
  • 我们需要知道父进程派给子进程的任务完成的如何，例如：子进程运行完成，结果是否正确，或者是否正常退出。
  • 父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息。

进程等待的方法

①wait方法

#include <sys/tyoes.h>
#include <sys/wait.h>
pid_t wait(int *status);

 注意：

用来验证回收僵尸的现象

返回值：成功返回被等待进程pid，失败返回-1

参数：输出型参数，获取子进程退出状态，不关心则可以设置成为NULL。

②waitpid方法

#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid,int *status, int options);

 注意：

用来获取子进程的退出信息（退出码+退出时的信号编号）

返回值：

  • 当正常返回的时候waitpid返回收集到的子进程的进程ID
  • 如果设置了选项WNOHANG，而调用waitpid发现没有已退出的子进程可收集，则返回0
  • 如果调用中出错，则返回-1，这时errno会被设置成相应的值以指示错误所在

参数pid:

  • pid=-1，等待任一个子进程。与wait等效
  • pid>0，等待其进程ID与pid相等的子进程

参数status：

  • 参数status是一个输出型参数，需要我们传入一个整型变量的地址，以获取子进程退出信息
  • WIFEXITED(status)：若为正常终止子进程返回的状态，则为真（查看进程是否正常退出）
  • WEXITSTATUS(status)：若WIFEXITED非零，提取子进程退出码（查看进程退出码）

参数options：

  • WNOHANG：若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID
  • 小结
  • 如果子进程已经退出，调用wait/waitpid时， wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。
  • 如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞
  • 如果不存在该子进程，则立即出错返回。

 获取子进程status

  • wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。
  • 如果传递NULL，表示不关心子进程的退出状态信息。否则操作系统会根据该参数，将子进程的退出信息反馈给父进程
  • status不能简单的当作整形来看待，可以当作位图来看待，具体如下图：

代码示例：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>

int main()
{
        pid_t pid;

        if((pid=fork())== -1)
        {
                perror("fork"),exit(1);
        }
        if(pid == 0)
        {
                sleep(20);
                exit(10);
        }
        else
        {
            int st;
            int ret = wait(&st);
                if(ret > 0 && (st & 0x7F) == 0)
                {
                        printf("child exit code:%d\n",(st>>8)&0xFF);
                }
                else if(ret > 0)
                {
                        printf("sig code:%d\n",st&0x7F);
                }
        }

        return 0;
}

 等待20秒：

在其他终端将其kill掉：

 阻塞、非阻塞代码实现

①阻塞等待方式


#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
int main()
{
     pid_t pid;
         pid = fork();
        if(pid < 0)
        {
                 printf("%s fork error\n",__FUNCTION__);
                 return 1;
        }
        else if( pid == 0 )
        { //child
                 printf("child is run, pid is : %d\n",getpid());
                 sleep(5);
                 exit(257);
        }
        else
        {
                 int status = 0;
                 pid_t ret = waitpid(-1, &status, 0);//阻塞式等待，等待5S
                 printf("this is test for wait\n");
                 if( WIFEXITED(status) && ret == pid )
                 {
                         printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));
                 }
                 else
                 {
                         printf("wait child failed, return.\n");
                         return 1;
                 }
        }
        return 0;
}

 

②进程的非阻塞等待方式 


#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
int main()
{
     pid_t pid;
         pid = fork();
        if(pid < 0)
        {
                 printf("%s fork error\n",__FUNCTION__);
                 return 1;
        }
        else if( pid == 0 )
        { //child
                 printf("child is run, pid is : %d\n",getpid());
                 sleep(5);
                 exit(1);
        }
        else
        {
                 int status = 0;
                 pid_t ret = 0;
                 do
                 {
                        ret = waitpid(-1,&status,WNOHANG);//非阻塞式等待
                        if(ret == 0)
                        {
                                printf("child is running\n");
                        }
                        sleep(1);
                 }while(ret == 0);

                 if( WIFEXITED(status) && ret == pid )
                 {
                         printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));
                 }
                 else
                 {
                         printf("wait child failed, return.\n");
                         return 1;
                 }
        }
        return 0;
}

 

 进程程序替换

我们一般在服务器设计(linux编程)的时候，往往需要子进程干两件事情

  • 让子进程执行父进程的代码片段
  • 让子进程执行磁盘中一个全新的程序

如何进行替换：

  1. 将磁盘中的程序，加载入内存结构
  2. 重新建立页表映射，谁执行程序替换就重新建立谁的映射（子进程）

效果：让我们的父进程和子进程彻底分离，并让子进程执行一个全新的程序 

替换原理

       用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变。

替换函数

①execl函数

int execl(const char *path, const char *arg, ....);

示例：

if(id ==0)
{
      //child
      //我们想让子进程执行全新的程序，以前是执行父进程的代码片段
      printf("我是子进程，我的pid是： %d\n",getpid());
      execl("/usr/bin/ls","ls","-a","-l",NULL);
      exit(1);
}
//一定是父进程
int status= 0;
int ret = waitpid(id, &status, 0);
if(ret == id)
{
     sleep(2);
     printf("父进程等待成功！\n");
}

 

②execlp函数 

int execlp(const char *file, const char *arg, ...);

示例： 

if(id ==0)
{
      //child
      //我们想让子进程执行全新的程序，以前是执行父进程的代码片段
      printf("我是子进程，我的pid是： %d\n",getpid());

      execlp("ls","ls","-a","-l",NULL);
      exit(1);
}
//一定是父进程
int status= 0;
int ret = waitpid(id, &status, 0);
if(ret == id)
{
     sleep(2);
     printf("父进程等待成功！\n");
}

 

③execle函数

int execle(const char *path, const char *arg, ..., char *const envp[]);

示例： 

mycmd.cpp

#include <iostream>
#include <stdlib.h>
int main()
{
//      std::cout << "PATH:" << getenv("PATH") <<std::endl;
        std::cout << "---------------------------------------"<<std::endl;
        std::cout << "MYPATH:" << getenv("MYPATH") << std::endl;
        std::cout << "---------------------------------------"<<std::endl;
        std::cout << "hello c++" << std::endl;
        std::cout << "hello c++" << std::endl;
        std::cout << "hello c++" << std::endl;
        std::cout << "hello c++" << std::endl;
        std::cout << "hello c++" << std::endl;
        return 0;
}

myexec.c

 if(id ==0)
{
      //child
      //我们想让子进程执行全新的程序，以前是执行父进程的代码片段

       printf("我是子进程，我的pid是： %d\n",getpid());

       char *const env_[] = {
            (char*)"MYPATH=YouCanSeeMe!",
             NULL
        };
    //  execle("./mycmd","mycmd",NULL,environ);
        execle("./mycmd","mycmd",NULL, env_);
        exit(1);
}

在代码自定义：

用environ设置：

④execv函数 

int execv(const char *path, char *const argv[]);

示例：

if(id ==0)
{
     //child
     //我们想让子进程执行全新的程序，以前是执行父进程的代码片段
     printf("我是子进程，我的pid是： %d\n",getpid());

     //char *const argv_[] = {
     //    (char*)"top",
     //     NULL
     // };

     char *const argv_[] = {
           (char*)"ls",
           (char*)"-a",
           (char*)"-l",
           (char*)"-i",
            NULL
      };
      //execv("/usr/bin/top",argv_);
      execv("/usr/bin/ls",argv_);
      exit(1);

}

 

⑤execvp函数

int execvp(const char *file, char *const argv[]);

示例：

if(id ==0)
{
     //child
     //我们想让子进程执行全新的程序，以前是执行父进程的代码片段
     printf("我是子进程，我的pid是： %d\n",getpid());
     char *const argv_[]={
         (char*)"top",
          NULL
     };
     execvp("top",argv_);
     exit(1);
}
//一定是父进程
int status= 0;
int ret = waitpid(id, &status, 0);
if(ret == id)
{
     sleep(2);
     printf("父进程等待成功！\n");
}

 ⑥execve函数

int execve(const char *path, char *const argv[], char *const envp[]);

示例： 

if(id ==0)
{
      //child
      //我们想让子进程执行全新的程序，以前是执行父进程的代码片段

      printf("我是子进程，我的pid是： %d\n",getpid());

      char *const env_[] = {
            (char*)"MYPATH=YouCanSeeMe!",
             NULL
       };
       char *const argv_[] = {
             (char*)"ls",
             (char*)"-a",
             (char*)"-l",
             (char*)"-i",
              NULL
       };
       execve("/usr/bin/ls",argv_,env_);
       exit(1);
}

 exec函数族如图所示：

 如图可看出，只有execve是真正的系统调用，其他五个函数最终都调用execve。

函数解释

  • 这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回。
  • 如果调用出错则返回-1，所以exec函数只有出错的返回值而没有成功的返回值。 

简易shell的实现 

用下图的时间轴来表示事件的发生次序。其中时间从左向右。shell由标识为sh的方块代表，它随着时间的流逝从左向右移动。shell从用户读入字符串"ls"。shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结束。

 

所以要自己实现一个简易shell，需要循环以下过程：

  • 获取命令行
  • 解析命令行
  • 建立一个子进程
  • 替换子进程
  • 父进程等待子进程退出

实现代码： 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <string.h>

#define SEP " "
#define NUM 1024
#define SIZE 128
char command_line[NUM];
char *command_args[SIZE];

//extern char** environ;

//对应上层的内建命令
int ChangDir(const char *new_path)
{
        chdir(new_path);
        return 0;
}

int main()
{
//shell本质上就是一个死循环
 while(1)
{
      //不关心获取这些属性的接口
      //1.显示提示符
      printf("[张三@我的主机名 当前目录]# ");
      fflush(stdout);

      //2获取用户输入
      memset(command_line,'\0',sizeof(command_line)*sizeof(char));
      fgets(command_line,NUM,stdin);//键盘，标准输入，stdin，获取到的是c风格的字符串，'\0'
      command_line[strlen(command_line) - 1] = '\0';//清空\n

      //3."ls -s -l -i" -> "ls" "-a" "-l" "-i" 字符串切分
      command_args[0] = strtok(command_line,SEP);
      //给ls命令添加颜色
      int index = 1;
      if(strcmp(command_args[0],"ls")== 0) command_args[index++] = (char*)"--color=auto";
      //strtok截取成功，返回字符串起始地址
      //截取失败，返回NULL
      while(command_args[index++] = strtok(NULL,SEP));

      //4.TODO，编写内建命令
      if(strcmp(command_args[0],"cd") == 0 && command_args[1] != NULL)
      {
            ChangDir(command_args[1]);
            continue;
      }

      //5.创建进程，执行
      pid_t id = fork();
      if(id == 0)
      {
             //child
             //6.程序替换
             //
             execvp(command_args[0],command_args);
              exit(1);
       }
       int status = 0;
       pid_t ret = waitpid(id,&status,0);
       if(ret > 0)
       {
              printf("等待子进程成功： sig: %d, code: %d\n",status&0x7F,(status>>8)&0xFF);
       }
}
return 0;
}
Linux中的进程控制
Pin_na
05-09 651
进程标识 进程创建 fork() fork用法： 父进程复制自己，使父子进程同时执行不同的代码段------在网络编程中最常见 一个进程要执行另一个不同的程序------shell的实现方式 一个现有的进程调用fork创建一个新进程，新进程为子进程。是父进程的一个副本，子进程拷贝父进程的数据段、堆和栈并独立使用，父子进程共享正文段（代码段）、内存映射。但是由于fork之后通常要调...
Linux--守护进程与会话
最新发布
m0_74068921的博客
09-18 2550
一个进程组可以包含多个进程。
Linux系统进程控制
weixin_47722127的博客
05-20 240
第七单元Linux系统进程控制 1：进程的定义 进程的定义： 程序是进程的代码文件 进程是指程序运行时的形态 进程是程序的一个副本 进程是有生命周期的（准备期，运行期，终止期） 进程&线程： 进程是资源调动的最小单位 线程是进程 的最小单位 程序执行流是从上到下贯穿运行的 当进程是多任务时，cpu是多核心，多任务应该被每个核心处理，每个核心处...
linux系统的进程控制
csdn_dsw的博客
03-30 1052
1.进程概念 进程是一个具有独立功能的程序的一次动态执行过程，简单的说，进程就是正在执行的程序。进程与程序不同，程序是永久的，静态的，而进程是暂时的，动态的。一个程序可以多次加载到内存中成为多个进程。 linux中的进程都由其它进程所创建（除了pid为0号的idle进程），创建新进程的进程叫父进程，新进程叫子进程。 2.进程的标识 在linux系统中，最重要的进程标识是进程号（Process Idenity Number,PID）。PID能唯一标识一个进程，PID是一个非零正整数。 获取当前进程P
Linux操作系统之进程控制
qq_61039408的博客
08-24 546
我们在之前就已经说过了，一开始父进程和子进程指向的其实都是同一份空间。此时，我们把页表项100这个部分改成非只读，这个时候我们就会发生进程往一个不可写的内存写入了，操作系统就会把进程中断，例如上面的图片，我本来是只读的，我把它改成可读可写了，这个时候映射关系就会出现问题了，操作系统这个时候检测到了之后就会把进程停止，发生缺页中断，然后修改页表和对应关系，这个时候我的子进程被中断了，不知道发生了什么，这是。修改完之后写时拷贝，物理内存分开。因此，进程创建从时间和空间上的成本都非常高。
Linux 进程控制
冰果滴的博客
10-16 1286
进程控制。
Linux进程调度器的设计--Linux进程的管理与调度(十七） - 嵌入式Linux中文站1
08-03
Linux进程调度器的设计是操作系统核心中的重要组成部分，其主要任务是高效、公平地分配CPU时间给系统中的各个进程，以确保系统的响应速度和整体性能。本文将深入探讨Linux进程调度器的基本原理、进程分类及其对应的...
Linux -- 信号控制进程 Kill 命令 简引
三毛与海子的博客
03-04 712
信号量有哪些 ？ 如何发送信号量 ？
嵌入式linux应用开发-linux进程控制开发
09-18
嵌入式linux应用开发-linux进程控制开发 1 基本概念 Linux中最主要的进程表示有进程号（PID）和它的父进程号（PPID），均是非零的正整数。 Linux中获得当前进程的PID和PPID的系统调用函数为getpid和getppid。...
Linux实验二：Linux-基本命令-进程管理.doc
10-29
本实验报告主要关注Linux中的进程组织结构、进程与控制终端的关系，以及作业管理。 首先，通过`pstree`命令我们可以观察到系统中进程的父子关系。在Linux启动后，`init`进程是最先启动的，它是所有其他进程的始祖。...
【Linux系统：进程控制】
m0_68872612的博客
03-29 1818
有关进程控制等知识的讲解，包括：进程创建，进程终止，进程等待，进程替换等知识。
Linux-进程控制
weixin_52199109的博客
10-24 2451
作为操作系统对于其中的进程控制，对于一个多进程少CPU的情况，操作系统要有一个组织调度进程的算法来合理分配资源。 进程调度队列 NICE与PRI 首先回顾一下NICE与PRI，这是表明进程的优先级的大小，越小，就代表进程优先级就越高。 NICE的范围是[-20,19],而PRI则默认是80.我们一般也只能通过控制NICE的值来间接影响PRI，从而改变进程的优先级。而NICE的区间也说明PRI的范围是[60,99]。也就是意味着，一个进程的优先级也就是在这个范围，且PRI越小，优先级越高。 运行队列-runq
Linux下的进程控制
gp1330782530的博客
08-15 600
Linux下的进程控制 1、进程创建 Linux下采用fork创建一个新进程，新进程为原来进程的子进程 #include <unistd.h> pid_t fork(void); 返回值，出错返回-1，父进程返回子进程的ID，子进程返回0 当一个进程调用fork以后，就会有两个二进制代码相同的进程，自此之后，父子进程分别执行各自的功能。 从如上的程序运行来看，当程序fork以后，自此之后的程序各自运行各自的程序，而不会打印两次before的内容注意，至于是两个进程谁先运行时取决于
Linux操作系统-进程控制
weixin_43164548的博客
03-25 5210
更深层次的理解进程，讲解了进程地址空间、进程等待、终止、程序替换等等知识
Linux进程控制
iwkxi的博客
08-29 580
所以最终采用写时拷贝：只会拷贝父子修改的，变相的，就是拷贝数据的最小成本，但是拷贝的成本依旧存在。废弃的内核结构的数据已经被释放了，但是内核结构开辟的空间还在，当你再次创建进程时，会把相应的task_struct和mm_struct重新初始化，就节省了重新开辟空间的消耗！父进程创建子进程之后，父子都有虚拟地址空间和页表，只不过子进程的各种隐射关系全部继承自父进程，所以父子的代码是共享的！通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。...
linux中的进程控制
baiduren__的博客
04-17 1281
linux中的进程控制
Linux —— 进程控制
weixin_59913110的博客
11-24 2144
介绍了进程创建、终止、替换、等待的基本概念和代码实例。介绍了一些常见问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值