学习笔记 day18 系统编程：进程及进程间通信

最新推荐文章于 2024-07-25 22:24:14 发布
最新推荐文章于 2024-07-25 22:24:14 发布
阅读量98 收藏
点赞数
文章标签： 学习 linux 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46420972/article/details/128709087
版权

多任务处理

一、进程

1、简介

/*
进程是一个具有一定独立功能的程序的一次运行活动，同时也是资源分配的最小单元;

程序是放到磁盘的可执行文件
进程是指程序执行的实例
进程与程序：
    进程是动态的，程序是静态的：程序是有序代码的集合；进程是程序的执行。通常进程不可在计算机之间迁移；而程序通常对应着文件、静态和可以复制
    进程是暂时的，程序是长久的：进程是一个状态变化的过程，程序可长久保存
    进程与程序组成不同：进程的组成包括程序、数据和进程控制块（即进程状态信息）
    进程与程序的对应关系：通过多次执行，一个程序可对应多个进程；通过调用关系，一个进程可包括多个程序。

进程的生命周期
	创建：每个进程都是由其父进程创建进程可以创建子进程，子进程又可以创建子进程的子进程
	运行：多个进程可以同时存在进程间可以通信
	撤销：进程可以被撤销，从而结束一个进程的运行
	
进程的状态
	执行状态：进程正在占用CPU
    就绪状态：进程已具备一切条件，正在等待分配CPU的处理时间片
    等待状态：进程不能使用CPU，若等待事件发生则可将其唤醒
*/
image-20230112112247228 
/*
Linux系统是一个多进程的系统，它的进程之间具有并行性、互不干扰等特点。也就是说，每个进程都是一个独立的运行单位，拥有各自的权利和责任。其中，各个进程都运行在独立的虚拟地址空间，因此，即使一个进程发生异常，它也不会影响到系统中的其他进程。

Linux中的进程包含3个段，分别为“数据段”、“代码段”和“堆栈段”。
    “数据段”存放的是全局变量、常数以及动态数据分配的数据空间；
    “代码段”存放的是程序代码的数据。
    “堆栈段”存放的是子程序的返回地址、子程序的参数以及程序的局部变量等。 

*/

/*
进程ID（PID)：标识进程的唯一数字
父进程的ID（PPID)
启动进程的用户ID（UID）

进程互斥：指当有若干进程都要使用某一共享资源时，任何时刻最多允许一个进程使用，其他要使用该资源的进程必须等待，直到占用该资源者释放了该资源为止

临界资源：操作系统中将一次只允许一个进程访问的资源称为临界资源

临界区：进程中访问临界资源的那段程序代码称为临界区，为实现对临界资源的互斥访问，应保证诸进程互斥地进入各自的临界区

进程同步：一组并发进程按一定的顺序执行的过程称为进程间的同步
   		具有同步关系一组并发进程称为合作进程，合作进程间互相发送的信号称为消息或事件

进程调度：按一定算法，从一组待运行的进程中选出一个来占有CPU运行。
		分为抢占式和非抢占式
		
调度算法：
	先来先服务调度算法
    短进程优先调度算法
    高优先级优先调度算法
    时间片轮转法

死锁：多个进程因竞争资源而形成一种僵局若无外力作用，这些进程都将永远不能再向前推进



*/

1、创建

1.1 fork
pid_t fork(void)
/*
功能：创建子进程
	fork的奇妙之处在于它被调用一次，却返回两次，它可能有三种不同的返回值：
	返回给父进程的值为子进程id
	返回给子进程的值为0
	返回值为-1表示创建子进程失败，无子进程
*/
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
int main(int argc, char const *argv[])
{   
    pid_t pid;
    int count=0;
    pid=fork();
    if(pid<0){
        perror("fork error!:");
        exit(-1);
    }
    else if(pid>0){
        count++;
        printf("pid = %d \t",getpid());
        printf("count = %d \n",count);
    }
    else{
        count++;
        printf("pid = %d \t",getpid());
        printf("count = %d \n",count);
    }
    
    return 0;
}
/*
执行结果为：
pid = 19585     count = 1 
pid = 19586     count = 1 
*/
1.2 vfork
pid_t vfork(void)
/*
功能：创建子进程
	返回给父进程的值为子进程id
	返回给子进程的值为0
	返回值为-1表示创建子进程失败，无子进程
	
在使用vfork时，子进程先执行，执行到return会将局部变量释放，从而导致父进程中的局部变量被释放。
*/
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
int main(int argc, char const *argv[])
{
    pid_t pid;
    int count=0;
    pid=vfork();
    if(pid<0){
        perror("fork error!:");
        exit(-1);
    }
    else if(pid>0){
        count++;
        printf("count = %d \n",count);
    }
    else{
        count++;
        printf("count = %d \n",count);
        _exit(0);//结束进程（系统调用，不会清空文件缓冲区、包含在unistd.h中）
    }
    //exit(0);//结束进程（c库函数实现、包含在stdlib.h中 不会释放变量，会清空文件缓冲区）
    return 0;
}
/*
执行结果为：
count = 1 
count = 2 
*/
1.3 fork 与 vfork
/*
1.	fork:子进程拷贝父进程的数据段
	vfork:子进程与父进程共享数据段

2.	fork:父、子进程的执行次序不确定
	vfork:子进程先运行，父进程后运行
*/

2、退出

/*

*/

3、等待

/*
父进程等子进程
一个进程结束以后，其父进程也结束，此进程为孤儿进程。
一个进程结束以后，其父进程未结束，可能形成僵尸进程。
僵尸进程占用系统资源,需要父进程清除。
*/
#include <sys/types.h>
#include <sys/wait.h>

pid_t wait (int * status)
/*
功能:阻塞该进程，直到其某个子进程退出。
*/
pid_t waitpid (pid_t pid,int * status,int options)
waitpid(-1,?,0)此时waitpid与wait相同
/*
pid:需要阻塞的进程id
options:设置阻塞或不阻塞
		0：阻塞等待
		WNOHANG：非阻塞
*/

4、exec（函数簇）

#include<unistd.h>
/*
exec用 被执行的程序 替换 调用它的程序。
区别:fork创建一个新的进程，产生一个新的PID。
	exec启动一个新程序，替换原有的进程，因此进程的PID不会改变
*/
int execl(const char * path,const char * arg1, ....)
/*
path：被执行程序名（含完整路径）。
arg1-argn: 被执行程序所需的命令行参数，含程序名。以空指针（NULL）结束。
*/
int execlp(const char * filename,const char * arg1, ....)
/*
filename:去默认路径（标准搜索目录）搜索该文件，若搜索不到，则执行出错
*/
int execle(const char * path,const char * arg1, ....,char *env[])
/*
filename:去默认路径（标准搜索目录）搜索该文件，若搜索不到，则执行出错
env:环境变量
*/

int execv(const char * path, char * const argv[ ])
/*
path：被执行程序名（含完整路径）。
argv[]: 被执行程序所需的命令行参数数组。
*/
int execvp(const char * filename,char * const argv[ ])
/*
filename:去默认路径（标准搜索目录）搜索该文件，若搜索不到，则执行出错
*/
int execve(const char * path,char * const argv[ ],char *env[])
/*
filename:去默认路径（标准搜索目录）搜索该文件，若搜索不到，则执行出错
env:环境变量
*/

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<stdlib.h>
int main(int argc, char const *argv[])
{
    pid_t pid;
    pid=fork();
    if(pid<0){
        perror("fork error!");
        exit(-1);   
    }
    else if(pid>0){
        
        int i=0;
        while(i<3){
            
            printf("this is in parent process!\n");
            sleep(1);
            i++;
        }
    }else{
        char *ch[]={"main","hello","world",NULL};
        //execl("/bin/ls","ls","-al","/home/jsetc/suqian",NULL);
        //execl("./main","main","hello","world",NULL);
        execv("./main",ch);
        //printf("2\n");
    }
    //exit(0);
    return 0;
}




#include <stdlib.h>

int system( const char* string )
/*
功能:调用fork产生子进程，由子进程来调用/bin/sh -c string来执行参数string所代表的命令
	相比于exec，此函数后续内容会继续执行
返回值：
		-1，调用出错
		==0，调用命令成功，但没有创建子进程
		>0，所创建的子进程的id
*/

二、进程通信

简介

/*
1.数据传输
    一个进程需要将它的数据发送给另一个进程
2.资源共享
    多个进程之间共享同样的资源
3.通知事件
    一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件
4.进程控制
    有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变

*/

/*
现在Linux使用的进程间通信方式包括：
1、管道（pipe）和有名管道（FIFO）
2、信号（signal）
3、消息队列
4、共享内存
5、信号量
6、套接字（socket）

*/

1、管道

/*
管道是单向的、先进先出的，半双工，它把一个进程的输出和另一个进程的输入连接在一起。
一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据

数据被一个进程读出后，将被从管道中删除，其它读进程将不能再读到这些数据。
管道提供了简单的流控制机制，进程试图读空管道时，进程将阻塞。同样，管道已经满时，进程再试图向管道写入数据，进程将阻塞

管道包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者可用于运行于同一系统中的任意两个进程间的通信。


先进先出
随内核存在，无法保存
管道由fork出的子进程继承

无名管道只能在具有亲缘关系的进程间通信

管道用于不同进程间通信。通常先创建一个管道，再通过fork函数创建一个子进程，该子进程会继承父进程所创建的管道
必须在系统调用fork( )前调用pipe( )，否则子进程将不会继承文件描述符

#include<unistd.h>
*/
int pipe(int filedis[2])；
/*
功能:创建一个管道。当一个管道建立时，它会创建两个文件描述符：filedis[0] 用于读管道， filedis[1] 用于写管道
*/

#include <sys/types.h>
#include <sys/stat.h>

int mkfifo(const char * pathname, mode_t mode)
/*
pathname：FIFO文件名
mode：属性

一旦创建了一个FIFO，就可用open打开它，一般的文件访问函数（close、read、write等）都可用于FIFO
*/
    
//使用无名管道实现字符串读写
#include<unistd.h>
#include<stdio.h>
#include<sys/types.h>
#include <sys/wait.h>
#include<string.h>
#include<stdlib.h>

int main(int argc, char const *argv[])
{
    int fd[2];
    int fd2[2];
    pid_t pid;
    char r_buf[6];
    char w_buf[10];
    int i;
    int cmd;
    int childexit=0;

    memset(r_buf,0,sizeof(r_buf));
    if(pipe(fd)<0)
    {
        perror("create pipe error!");
        exit(-1);
    }
    else
    {
        printf("create pipe successfully!\n");
    }
    if(pipe(fd2)<0)
    {
        perror("create pipe error!");
        exit(-1);
    }
    else
    {
        printf("create pipe2 successfully!\n");
    }
    if((pid=fork())<0)
    {
        perror("fork error!");
        close(fd[0]);
        close(fd[1]);
        close(fd2[0]);
        close(fd2[1]);
        exit(-1);
    }
    else if (0==pid)
    {
        close(fd[1]);
        close(fd2[0]);
        read(fd[0],r_buf,6);
        printf("r_buf:%s\n",r_buf);
        for(int j=0;r_buf[j];j++){
            r_buf[j]-=32;
        }
        write(fd2[1],r_buf,6);
        close(fd[0]);
        close(fd2[1]);
        _exit(0);
   
    }
    else
    {
        close(fd[0]);
        close(fd2[1]);
        write(fd[1],"hello",6);
        read(fd2[0],w_buf,6);
        printf("w_buf:%s\n",w_buf);
        close(fd[1]);
        close(fd2[0]);
    }
    wait(NULL);
    return 0;
}

//使用有名管道实现读写
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<sys/stat.h>
#include<string.h>
#include<fcntl.h>
#define FIFO "./1"
int main(int argc, char const *argv[])
{
    int fd;
    pid_t pid;
    if(mkfifo(FIFO,0666)<0)
    {
        perror("create pipe error!");
        exit(-1);
    }
    else
    {
        printf("create pipe successfully!\n");
    }

    if((pid=fork())<0)
    {
        perror("fork error!");
        exit(-1);
    }
    else if (0==pid)
    {
        char s[6]="0";
        fd=open(FIFO,O_RDONLY);
        read(fd,s,6);
        puts(s);
        close(fd);
    }
    else
    {
        fd=open(FIFO,O_WRONLY);
        write(fd,"hello",6);
        close(fd);
        
    }
    return 0;
}

3、信号

/*
所有进程通信方式中唯一一个异步通信方式

信号(signal)机制是Unix系统中最为古老的进程间通信机制，很多条件可以产生一个信号：
		1、当用户按某些按键时，产生信号
	  	2、硬件异常产生信号：
            除数为0、无效的存储访问等等。
            这些情况通常由硬件检测到，将其通知内核，然后内核产生适当的信号通知进程，
            例如，内核对正访问一个无效存储区的进程产生一个SIGSEGV信号
     	3、进程用kill函数将信号发送给另一个进程
     	4、用户可用kill命令将信号发送给其他进程

下面是几种常见的信号：
	SIGHUP： 从终端上发出的结束信号
	SIGINT： 来自键盘的中断信号（Ctrl-C）
	SIGKILL：该信号结束接收信号的进程
	SIGTERM：kill 命令发出的信号
	SIGCHLD：标识子进程停止或结束的信号
	SIGSTOP：来自键盘（Ctrl-Z）或调试程序的停止执行信号
*/

/*
当某信号出现时，将按照下列三种方式中的一种进行处理：
1、忽略此信号
	大多数信号都按照这种方式进行处理，但有两种信号却决不能被忽略,它们是：SIGKILL\SIGSTOP。
	这两种信号不能被忽略的原因是：它们向超级用户提供了一种终止或停止进程的方法
2、执行用户希望的动作
	通知内核在某种信号发生时，调用一个用户函数。在用户函数中，执行用户希望的处理
3、执行系统默认动作
	对大多数信号的系统默认动作是终止该进程

*/
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int signo)
int raise(int signo)
/*
kill既可以向自身发送信号，也可以向其他进程发送信号。
与kill函数不同的是，raise函数是向进程自身发送信号

kill的pid参数有四种不同的情况：
    1、pid > 0
       将信号发送给进程ID为pid的进程。
    2、pid == 0
       将信号发送给同组的进程。
    3、pid < -1
       将信号发送给其进程组ID等于pid绝对值的进程。
    4、pid == -1
        将信号发送给所有进程。
返回值：
	-1发送信号失败
	0发送成功
*/
#include<unistd.h>
unsigned int alarm(unsigned int seconds)
/*
Seconds：经过了指定的seconds秒后会产生信号SIGALRM。
    每个进程只能有一个闹钟时间.如果在调用alarm时，以前已为该进程设置过闹钟时间，而且它还没有超时，以前登记的闹钟时间则被新值代换
    如果有以前登记的尚未超过的闹钟时间，而这次seconds值是0，则表示取消以前的闹钟
    第二次alarm的返回值是前一次alarm剩余的时间

使用alarm函数可以设置一个时间值(闹钟时间)，当所设置的时间到了时，产生SIGALRM信号.如果不捕捉此信号，则默认动作是终止该进程

*/
int pause(void)
/*
pause函数使调用进程挂起直至捕捉到一个信号。只有执行了一个信号处理函数后，挂起才结束

*/

/*

*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
int main(int argc, char const *argv[])
{
    pid_t pid;
    int ret;

    if((pid=fork())<0){
        perror("fork error!");
        exit(-1);
    }
    else if(0==pid){
        raise(SIGSTOP);
        exit(0);
    }
    else{
        printf("pid=%d\n",pid);
        if(waitpid(pid,NULL,WNOHANG)==0){
        //if(waitpid(pid,NULL,0)==0){
            if((ret=kill(pid,SIGKILL))==0){
                printf("killed %d\n",pid);
            }
            else{
                perror("kill error!");
            }
        }
    }
    return 0;
}



#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

int main(int argc, char const *argv[])
{
    int ret;
    ret=alarm(5);
    pause();
    printf("i have been wake up!\n");
    return 0;
}
牛奶奥利奥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
学习笔记信号量和进程间通信
03-29
本学习笔记将深入探讨信号量和进程间通信的相关概念、原理以及实际应用。 首先，让我们理解什么是进程。进程是程序执行的实例，拥有独立的内存空间和系统资源，它们在操作系统中并行运行。在多进程环境中，为了协调...
学习笔记(06):19年并发编程及原理视频培训教程入门到精通-进程与线程的区别…
01-20
因此，进程间的通信通常需要通过特定的机制，如管道、套接字或共享文件来实现。 相比之下，线程是进程内部的执行单元，是CPU调度和分派的基本单位。线程也被称作轻量级进程，因为它们共享同一进程的地址空间。这...
学习笔记 day19 系统编程：进程间通信
weixin_46420972的博客
01-29 79
【代码】学习笔记 day19 系统编程：进程间通信。
操作系统学习笔记（day6）进程通信
无
05-09 1862
知识点1. 进程通信概念1.1 低级进程通信1.2 高级进程通信2. 进程通信的类型2.1 共享存储器系统（Shared-Memory System）2.2 管道（pipe）通信系统2.3 消息传递系统（Message passing system）2.4 客户机-服务器系统（Client-Server system）消息传递通信的实现方式直接传递消息系统实例 先思考几个问题： 什么是进程通信？...
Linux系统编程——进程间通信
Alliswell_WP
07-01 214
在学习Linux系统编程总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 09-linux-day06(进程间通信) 目录：一、学习目标二、进程通信——管道1、管道的概念2、管道通信举例3、父子进程实现ps、grep命令4、ps、grep命令实现问题解决5、管道的读写行为6、管道大小和优劣三、进程通信——FIFO1、fifo实现通信写端2、fifo...
Linux系统编程【文件IO、进程、进程间通信、信号、线程、互斥】
weixin_45045804的博客
09-29 1569
个人通过学习，手打了一份48000字的Linux系统编程的笔记，包含了【文件IO、进程、进程间通信、信号、多线程、互斥】等知识点，并给出了大量的代码案例对每个重要的知识点进行了代码演示，通过理论和实操的结合，更好的透析每个知识点，为后续的unix网络编程打下基础。
Linux系统编程——09-linux-day06(进程间通信)
Alliswell_WP
07-01 173
在学习Linux系统课程总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 09-linux-day06(进程间通信) 一、学习目标 1、熟练使用pipe进行父子进程间通信 2、熟练使用pipe进行兄弟进程间通信 3、熟练使用fifo进行无血缘关系的进程间通信 4、熟练掌握mmap函数的使用 5、掌握mmap创建匿名映射区的方法 6、使用mm...
JAVA学习笔记-JAVA基础语法-DAY22-网络编程
zzq393109417的博客
07-03 893
TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端（Server）。1. 服务端程序，需要事先启动，等待客户端的连接。2. 客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。1. 客户端： java.net.Socket 类表示。创建 Socket 对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。2. 服务端： java.net.ServerSocket 类表示。
系统编程学习笔记
linping_的博客
08-18 862
基础知识 不会的命令可以查看 鸟哥私房菜这本书 或者自带的帮助文档 man 命令 ifconfig ： 查看 IP 地址，MAC地址 可以用 ip 代替，ifconfig已经过时了 增加用户 sudo adduser client 密码：0000 pwd 重命名文件 mv既可用于改名，也可用于移动 mv mytest newtest （如果第二个参数是文件，那么就是改名，如果是目录就是移动至该目录。） kill pid ：杀死某个进程 killall 服务名：杀死这个服务对应的所有进程 创建文件：to
Python学习 Day10 进程与线程（一）
weixin_45492364的博客
05-20 2044
进程（Process）是操作系统资源分配和调度的基本单位，是操作系统结构的基础。每个进程有自己的内存空间和系统资源，执行过程中保持独立。进程是程序的实体，代表一次程序执行过程，一个进程可以包含多个线程。线程（Thread）是操作系统的最小单位，是CPU资源分配和调度的基本单位。线程包含在进程当中，同一个进程中的线程共享进程拥有的全部资源，又各自有自己独立的资源。线程是进程中的一个执行单元，负责执行进程中的代码和指令；进程中的不同线程独立的执行不同的任务或者任务的一部分。可以说，
Java学习路线：day18 多线程
杨丙寅
05-18 1522
文章目录第8章 多线程基本概念：程序、进程、线程进程与线程使用多线程的优点何时需要多线程线程的创建和使用线程的创建和启动Thread类API中创建线程的两种方式创建多线程的方式一：继承Thread类创建过程中的两个问题说明练习1Thread类的有关方法线程的调度线程的优先级练习2练习3创建多线程的方式二：实现Runnable接口继承方式和实现方式的联系与区别补充：线程的分类 原文：https:/...
笔记_UNIX环境网络编程卷二进程间通信_中文第二版.pdf
06-16
笔记_UNIX环境网络编程卷二进程间通信_中文第二版
Flutter学习笔记：有状态组件和组件间通信
01-08
再学习过程中在本例子中用到了几个注意点进行笔记： Flutter有状态组件的定义方法 Flutter子组件和父组件之间的通信过程 动态组件生成的方法 关于定义回调函数类型上碰到的写法问题 实现效果： 1. Flutter有状态...
python学习笔记之多进程
12-17
值得注意的是，`multiprocessing`模块中的进程间通信（IPC）功能也很强大，包括队列（Queue）、管道（Pipe）和共享内存等。这些工具使得进程间的数据交换成为可能，但同时也需要开发者考虑同步和互斥的问题，以防止...
AvaloniaUI的学习
最新发布
lishuangquan1987的博客
07-25 768
官方中文文档：https://docs.avaloniaui.net/zh-Hans/docs/welcome。
Python编程学习第一篇——Python零基础快速入门（六）（4）异常处理
urhero的专栏
07-25 267
我们已经了解了Python的基本数据类型、变量和基本的逻辑控制语句，基于这些基础知识可以编写一些小程序了，但是在写程序的时候我们会发现，有时候程序并不是按我们预期的方向执行，有的直接报错，有的没有报错，却并未得到我们预期的结果。在这个例子中，除数为0会引发ZeroDivisionError异常，我们将异常信息赋值给变量e，并输出"除数不能为0"和异常信息。在这个例子中，由于除数不为0，所以没有发生ZeroDivisionError异常，代码会执行else语句块，并输出结果2.0。
Spring Security学习笔记（二）Spring Security认证和鉴权
飞！！！的博客
07-24 686
用户认证的基础Filter，只有UsernamePasswordAuthenticationFilter这一个实现类。...//主要方法//先校验请求url与表单校验提交的url是否一致，不一致执行下一个Filter//一致的话就执行认证逻辑，一般默认的表单提交url是"/login"if (!} else {try {//实现类执行具体的认证逻辑return;//由子类实现具体的验证逻辑...
FastAPI（八十）实战开发《在线课程学习系统》接口开发-- 课程列表
mr~li的博客
07-25 245
源码见："
王道操作系统学习笔记：进程、线程与调度策略解析
"这是关于B站王道操作系统学习笔记的PDF文档，涵盖了操作系统的基本概念、进程、线程、核心态与用户态、中断、并发、进程调度策略等多个知识点。笔记详细阐述了操作系统的功能、发展历程、运行机制以及系统调用等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

牛奶奥利奥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值