Linux进程间通信

已于 2023-03-08 21:08:00 修改
阅读量569 收藏 1
点赞数
分类专栏： Linux 文章标签： linux 队列
于 2020-12-24 08:55:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51247005/article/details/111603540
版权

目录

1、通信技术IPC(InterProcess Communication)

1.IPC方式有:
＊管道(包括无名管道和命名管道)
＊消息队列
＊信号量
＊共享存储
＊Socket
＊Streams
Socket和Streams支持多机通信

2、无名管道

1.半双工，只在父子进程之间，管道可以看成特殊文件用read write读写只存在于内存不生成文件。
2.原型

int pipe(int fd[2])

返回值:成功0，失败－1
管道建立成功生成2个文件描述符，fd[0]读，fd[1]写
3.用法举例
建立管道:pipe(fd)，判断是否成功
创建子进程:fork，判断是否成功
在父子进程读写:父进程写，子进程读
父:close(fd[0])，write(fd[1]，内容，个数)
子:close(fd[1])，read(fd[0]，，)
注:写时要关闭读管道，读时要关闭写管道
读写方向一但固定就无法改变。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main ()
{
        pid_t pid;
        int fd[2];
        char a[10] = {0};
        if(pipe(fd) == -1)
        {
                perror("pipe");
                exit(-1);
        }
        pid = fork();
        if(pid < 0)
        {
                perror("fork");
                exit(-1);
        }
        else if(pid == 0)
        {
                close(fd[1]);
                read(fd[0],a,strlen("xiao wei"));
                printf("%s\n",a);
        }
        else
        {
                close(fd[0]);
                write(fd[1],"xiao wei",strlen("xiao wei"));
        }
        return 0;
}

3、命名管道(FIFO)

1.半双工，可以无关进程之间，以特殊文件形式存在文件系统
2.原型

int mkfifo(const char* pathname，mode_t mode)

返回值:成功0 ，失败－1，可以用perror查看失败原因
参数:和open一样，文件路径名，0600(读写)
参数1:可设置是否阻塞O_NONBLOCK，默认是阻塞。
3.例:
＊进程1
open打开管道
read阻塞等待write(要用while)
输出读的数据
close关闭管道
＊进程2
open打开管道
write写数据
close关闭管道
注:管道文件数据读后立马清空，先进先出

/*读代码*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
int main ()
{
        int cnt = 3;
        int fd;
        char a[14] = {0};
        if(mkfifo("./fifo",0600) == -1 && errno != EEXIST)
        {
                perror("pipe");
                exit(-1);
        }
        fd = open("./fifo",O_RDONLY);
        if(fd == -1)
        {
                perror("open");
        }
        while(cnt)
        {
                read(fd,a,13);
                printf("read:%s\n",a);
                cnt--;
        }
        close(fd);
        return 0;
}
/*写代码*/
int main ()
{
        int cnt = 3;
        int fd;
        char *a = "xiao wei ...";
        fd = open("./fifo",O_WRONLY);
        if(fd == -1)
        {
                perror("open");
                exit(-1);
        }
        while(cnt)
        {
                write(fd,a,strlen(a));
                sleep(3);
                cnt--;
        }
        close(fd);
        return 0;
}
/*运行结果*/
/*
读进程那边输出：
read:xiao wei ...
read:xiao wei ...
read:xiao wei ...
写进程没3秒发数据一次，发3次后退出程序
*/

4、消息队列

4.1.

全双工，链表在内核中有标识符(队列ID)，随机查询按类型读取，进程终止内容不会删除

4.2.API

int msgget(key_t key,int flag)

创建消息队列，成功返回0，失败－1
参数1:key可以用ftok函数，也可以直接写0x1234
参数2:创建队列IPC_CREAT，打开方式可读可写可执行0777

int msgsnd(int msqid,const void*ptr,size_t size,int flag)

添加消息，成功0失败－1
参数1:队列号key
参数2:结构体指针

struct msgbuf
{
     long mtype;
     char mtext[1];
}

参数3:个数用strlen算
参数4:0非阻塞

int msgrcv(int msqid,void*ptr,size_t size,long type,int flag)

读取消息，成功返回数据长度
参数1:队列号
参数2:结构体指针
参数3:个数
参数4:消息类型，结构体的mtype
参数5:0阻塞等待

int msgctl(int msqid,int cmd,struct msqid_ds*buf)

控制消息队列，释放移除队列
参数1:队列号
参数2:常用IPC_RMID，释放移除队列
参数3:通常NULL

4.3.ftok函数(通常用于消息队列)

key_t ftok(const char*fname，int id)

返回值:key，队列号
参数1:当前目录
参数2:id
例:key=ftok(“.”，‘a’)

4.4例:

创建结构体
创建队列
接受消息，发送消息
移除队列

/*读代码*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
struct msgbuf {
        long mtype;       /* message type, must be > 0 */
        char mtext[128];    /* message data */
};
int main()
{
        struct msgbuf readbuf;
        memset(&readbuf,0,sizeof(struct msgbuf));
        key_t key;
        key = ftok(".",'z');
        int msgid = msgget(key,IPC_CREAT|0777);
        if(msgid == -1)
        {
                printf("get que failuer\n");
        }
        msgrcv(msgid,&readbuf,sizeof(readbuf.mtext),666,0);
        printf("readbuf:%s\n",readbuf.mtext);
        msgctl(msgid,IPC_RMID,NULL);
        return 0;
}
/*写代码*/
struct msgbuf {
        long mtype;       /* message type, must be > 0 */
        char mtext[128];    /* message data */
};
int main()
{
        struct msgbuf writebuf = {666,"xiao wei..."};
        key_t key;
        key = ftok(".",'z');
        int msgid = msgget(key,IPC_CREAT|0777);
        if(msgid == -1)
        {
                printf("get que failuer\n");
        }
        msgsnd(msgid,&writebuf,strlen(writebuf.mtext),0);
        msgctl(msgid,IPC_RMID,NULL);
        return 0;
}
/*运行结果*/
/*
先运行读
在运行写
读端输出
readbuf:xiao wei...
后结束程序
*/

5、共享内存

1.共用一个内存，写读用指针指向这个内存
不能同时往里面写数据，需要信号量来互斥
2.API

int shmget(key_t key，size_t size，int flag)

创建打开一个共享内存
返回值:成功返回id，失败返回－1
参数1:key，用ftok
参数2:创建内存大小，必须以m为单位
参数3:创建共享内存IPC_CREAT，可读写0666
例:shmip=shmget(key，1024＊4，IPC_CREAT|0666)

void *shmat(int shm_id，const void* addr，int flag)

连接共享内存地址空间
返回值:成功返回地址，失败－1
参数1:共享内存id
参数2:0
参数3:0
注:这个指针不需要free释放

int shmdt(void* addr)

断开连接
返回值:成功0失败－1
参数:id

int shmctl(int shm_id，int cmd，struct shmid_ds* buf)

控制共享内存，释放
返回值:成功0失败－1
参数1:id
参数2:IPC_RMID
参数3:0
3.例:
创建打开共享内存
连接映射共享内存
读写数据(用printf)
断开连接
释放干掉共享内存

//写
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
int main()
{
        int shm_id;
        char *shmatadd;
        key_t key;
        key = ftok(".",'a');
        shm_id = shmget(key,1024*4,IPC_CREAT|0666);
        if(shm_id == -1){
                printf("found fail\n");
                exit(-1);
        }
        shmatadd = shmat(shm_id,0,0);
        printf("shmat ok\n");
        strcpy(shmatadd,"xiaowei");
        sleep(3);

        shmdt(shmatadd);
        shmctl(shm_id,IPC_RMID,0);
        return 0;
}

//读
int main()
{
        int shm_id;
        char *shmatadd;
        key_t key;
        key = ftok(".",'a');
        shm_id = shmget(key,1024*4,0);
        if(shm_id == -1){
                printf("found fail\n");
                exit(-1);
        }
        shmatadd = shmat(shm_id,0,0);
        printf("shmat ok\n");

        printf("data:%s\n",shmatadd);

        shmdt(shmatadd);
        printf("quit\n");
        return 0;
}

/*判断共享内存内容，是否和上次内容一样
不一样做什么*/
if(strcmp(cmd1,shmatadd)){
	strcpy(cmd1,shmatadd);
	printf("cmd=%s\n",cmd1);
}
/*
strcpy(cmd,shmatadd);
if(strcmp(cmd,cmd1)){
	strcpy(cmd1,cmd);
	printf("cmd1= %s\n",cmd1);
}
*/              
if((strcmp(cmd1,"quit") == 0) || (a == 60)){
	printf("quit\n");
	break;
}

6、信号

一、一些命令
1.用指令kill －l，查看信号名称和编号
2.忽略，捕捉，系统默认信号
3.使用
例:杀死进程
kill －信号编号 进程pid
二、信号注册，捕捉，忽略(入门)
1.API
函数:

tpyedef void(*sighandler_t)(int)

函数指针

sighandler_t signal(int signum，sighandler_t handler)

参数1:信号名称
参数2:函数指针
高级:sigaction()

2.用signal捕捉信号，然后用函数指针更改系统默认信号，改成自己要操作的内容。
例:
捕捉信号
进入函数指针里，操作要干什么
注:9 SIGKILL，系统信号改变不了

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

void handler(int signum)
{
        printf("get signum:%d\n",signum);
        switch(signum){
                case 2:
                        printf("SIGINI\n");
                        break;
                case 9:
                        printf("SIGKILL\n");
                        break;
                case 10:
                        printf("SIGUSR1\n");
                        break;
        }
        printf("never quit\n");
}
int main()
{
        signal(SIGINT,handler);
        signal(SIGKILL,handler);
        signal(SIGUSR1,handler);
        while(1);
}
/*
用kill -9 进程pid，杀死进程
用kill-2 pid ，输出SIGINI（还可以用CTRL+c）
用kill -10 pid 输出SIGUSR1
*/

3.用函数main传参杀死进程
＊API

int kill(pid_t pid，int sig)

发信号，杀死进程
参数:1.进程pid，2.信号编号加－

atoi()//char转int

参数:二级指针，mian形参
sprintf()
做字符串
参数:比printf前面多一个参数，char是指针型，做出来的字符串放到char＊里面
＊例:
main完整有形参
把2个字符型形参用atoi转整型(pid，signum)
2种方法
用kill杀死进程
用sprintf做字符串，在用system杀死进程

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

int main(int argc,char **argv)
{
        int signum;
        int pid;
        char cmd[128] = {0};
        signum = atoi(argv[1]);
        pid = atol(argv[2]);
        sprintf(cmd,"kill %d %d",signum,pid);
        system(cmd);
        printf("send signal ok\n");
        return 0;
}
//使用：./a -9 2313

4.忽略信号
signal第二个参数写宏，SIG_ICN
注:忽略不了信号9
三、信号携带信息，收发(高级)
1.sigaction(捕捉信号)

int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);

参数1:信号编号
★参数2:结构体指针
参数3:备份，NULL
一般用法:都配置
2.struct sigaction

struct sigaction {
        void     (*sa_handler)(int);
        void     (*sa_sigaction)(int, siginfo_t *, void *);
        sigset_t   sa_mask;
        int        sa_flags;
        void     (*sa_restorer)(void);
};

成员1:和signal的函数指针一样
★成员2:多个形参的函数指针
成员3:是否阻塞，默认阻塞
成员4:SA_SIGINFO
成员5:一般不用
一般用法:配成员2,4
3.函数指针handler()
参数1:int signum接受到的信号类型编号
参数2:结构体siginfo_t，读数据:si_int，pid，发消息:一个联合体,可以发整型和字符。
参数3:void＊context指针,判断是否有数据传过来，无数据指向空NULL

si_pid //发送者的pid
si_int //整型数
si_value //联合体

union sigval{
	int sival_int;
	void *sivl_ptr;
};

siginfo_t {
         int      si_signo;     /* Signal number */
         int      si_errno;     /* An errno value */
         int      si_code;      /* Signal code */
         int      si_trapno;    /* Trap number that caused
                                   hardware-generated signal
                                   (unused on most architectures) */
         pid_t    si_pid;       /* Sending process ID */
         uid_t    si_uid;       /* Real user ID of sending process */
         int      si_status;    /* Exit value or signal */
         clock_t  si_utime;     /* User time consumed */
         clock_t  si_stime;     /* System time consumed */
         sigval_t si_value;     /* Signal value */
         int      si_int;       /* POSIX.1b signal */
         void    *si_ptr;       /* POSIX.1b signal */
         int      si_overrun;   /* Timer overrun count;
                                   POSIX.1b timers */
         int      si_timerid;   /* Timer ID; POSIX.1b timers */
         void    *si_addr;      /* Memory location which caused fault */
         long     si_band;      /* Band event (was int in
                                   glibc 2.3.2 and earlier) */
         int      si_fd;        /* File descriptor */
         short    si_addr_lsb;  /* Least significant bit of address
                                   (since Linux 2.6.32) */
         void    *si_lower;     /* Lower bound when address violation
                                   occurred (since Linux 3.19) */
         void    *si_upper;     /* Upper bound when address violation
                                   occurred (since Linux 3.19) */
         int      si_pkey;      /* Protection key on PTE that caused
                                   fault (since Linux 4.6) */
         void    *si_call_addr; /* Address of system call instruction
                                   (since Linux 3.5) */
         int      si_syscall;   /* Number of attempted system call
                                   (since Linux 3.5) */
         unsigned int si_arch;  /* Architecture of attempted system call
                                   (since Linux 3.5) */
}

例:
sigaction函数
配置结构体2个成员
写handler函数
函数里判断有数据打印数据
发送
1.sigqueue

 int sigqueue(pid_t pid, int sig, const union sigval value);

参数1:给谁发pid
参数2:发什么信号
参数3:数据，联合体union sigval(整型，字符)

union sigval {
    int   sival_int;
    void *sival_ptr;
};

例:
用完整main，2个参数转int
函数sigqueue
写数据联合体(特别注意段错误，共用一个内存，写字符的时候要用指针)

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

void handler(int signum, siginfo_t *info, void *context)
{
        printf("get signum %d\n",signum);
        if(context != NULL){
                printf("get data:%d\n",info->si_int);
                printf("get data:%d\n",info->si_value.sival_int);
                printf("from:%d\n",info->si_pid);
        }
}

int main()
{
        struct sigaction buf;

        buf.sa_sigaction = handler;
        buf.sa_flags = SA_SIGINFO;

        sigaction(SIGUSR1,&buf,NULL);

        while(1);
        return 0;
}
/*输出
get signum 10
get data:10
get data:10
from:48116
*/

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
int main(int argc,char **argv)
{
        int signum;
        int pid;
        union sigval value;
        value.sival_int = 10;
        signum = atoi(argv[1]);
        pid = atol(argv[2]);
        sigqueue(pid,signum,value);
        printf("%ddone\n",getpid());
        return 0;
}

7、信号量(锁)

1.控制谁先运行
2.API

int semget(key_t key，int num_sems，int sem_flags)

创建，获取信号组
返回值:semid
参数:key，用flok
参数:信号组个数，一般
参数:IPC_CREAT|0666

int semop(int semid，struct sembuf *sops，size_t numops)

操作信号量，改变值
参数1:id
参数2:结构体指针可以有多个也可以是一个，
成员:sem_num，信号量编号0
成员:sem_op，操作信号量，－1,1
成员:sem_flg，SEM_UNDO
参数3:几个信号量

int semctl(int semid，int sem_num，int cmd，...)

控制信号量组相关信息
参数:id
参数:操作第几个信号量，0开始
参数:很多宏，常用SETVAL设置信号量值
IPC_RMID销毁
参数:联合体，union semun，开头要定义
初始化设置信号量值为1，联合体val=1
例:
创建信号量组
初始化信号量
创建父子进程
写2个函数，一个信号量加，一个减
子进程运行完信号量加
父进程先减然后运行在加
销毁锁

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>
union semun {
               int              val;    /* Value for SETVAL */
               struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
               unsigned short  *array;  /* Array for GETALL, SETALL */
               struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                           (Linux-specific) */
           };
void pGetKey(int id)
{
        struct sembuf set;
        set.sem_num = 0;
        set.sem_op = -1;
        set.sem_flg = SEM_UNDO;
        semop(id,&set,1);
        printf("getkey\n");
}

void vPutBackKey(int id)
{
        struct sembuf set;
        set.sem_num = 0;
        set.sem_op = 1;
        set.sem_flg = SEM_UNDO;
        semop(id,&set,1);
        printf("put back the key\n");
}
int main()
{
        key_t key;
        int sem_id;
        key = ftok(".",'a');
        union semun initsem;
        initsem.val = 0;//锁初始没有钥匙

        sem_id = semget(key,1,IPC_CREAT|0666);
        semctl(sem_id,0,SETVAL,initsem);

        int pid = fork();
        if(pid > 0){
                pGetKey(sem_id);//父进程那不到，因为没有钥匙
                printf("this is father\n");
                vPutBackKey(sem_id);
        }else if(pid == 0){
                printf("this is child\n");
                vPutBackKey(sem_id);//子进程执行完，放钥匙进去
        }else
        {
                printf("fork error\n");
                exit(-1);
        }

        semctl(sem_id,0,IPC_RMID);
        return 0;
}
dz小伟
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
linux系统的1号进程,linux 1号进程
weixin_35173650的博客
04-28 4866
linux 1号进程1号进程，pid为1的进程，又称init进程。linux系统启动后，第一个被创建的用户态进程就是init进程。它有两项使命：1、执行系统初始化脚本，创建一系列的进程(它们都是init进程的子孙);2、在一个死循环中等待其子进程的退出事件，并调用waitid系统调用来完成“收尸”工作;init进程不会被暂停、也不会被杀死(这是由内核来保证的)。它在等待子进程退出的过程中处于TAS...
Linux进程通信
qq_39480875的博客
01-28 820
Linux进程通信 在Linux环境下，用c语言编程，使用系统调用fork创建进程多个子进程。 fork():建立子进程。子进程得到父进程地址空间的一个复制。 返回值：成功时，该函数被调用一次，但返回两次，fork（）对子进程返回0，对父进程返回子进程标识符（非0值）。不成功时对父进程返回-1，没有子进程。 (1) 调试并完成下列程序，完成实验要求： #include &amp;amp;quot;stdio.h&amp;amp;quot; int ...
解析 linux 进程 pid 0, pid 1, pid 2 关系及启动过程
热门推荐
m0_47696151的博客
12-15 1万+
Linux 中有 pid 0, pid 1 和 pid 2 三个特殊的进程。 本文以 Linux v2.6.39 为例，说明 Linux中这三个进程的关系及启动过程
Linux系统编程之进程控制
m0_67168421的博客
07-29 321
每个进程都有非负整数表示的唯一进程ID，即pid，其类型为pid_t类型。可用ps命令查看当前所有进程的信息，该命令可以加选项，一般使用ps -ef或ps axf(打印进程树)，查看当前系统所有进程的信息。需要注意的是和fd(文件描述符)不同，pid是顺次使用的，即当10001，10002，10003被用过后，10002释放了，下个进程的pid会继续使用10004而不是回头使用最小的可用pid10002。pid为1的进程是init进程，它是所有进程的祖先进程。
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
linux-linux进程间通信方式汇总.zip
最新发布
02-26
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是多个进程之间共享数据、交换信息的关键技术。本文将全面解析Linux中的各种进程间通信方式，帮助你深入理解这一核心概念。 首先，我们来了解...
浅谈Linux进程间通信方式及优缺点
01-11
有名管道也是一种半双工的通信方式,但是它允许无亲缘关系进程间的通信。 2)信号量 信号量是一个计数器,可以用来控制多个线程对共享资源的访问.,它不是用于交换大批数据,而用于多线程之间的同步.它常作为一种锁机制...
Linux进程间通信--使用信号
09-15
Linux进程间通信是一种让不同进程之间交换信息或协调工作的方式，而在Linux系统中，信号（Signal）是一种简单但重要的通信机制。本文将深入探讨如何利用信号进行进程间通信。 首先，信号是操作系统用来通知进程发生...
Linux进程间通信.zip
07-02
本资料包“Linux进程间通信.zip”着重介绍了几种主要的IPC机制，包括fifo（命名管道）、pipe（匿名管道）以及mmap（内存映射），并预告了后续将涉及的消息队列和信号。下面我们将详细探讨这些通信方式。 1. **fifo...
Linux 进程间通信
12-16
Linux进程间的通信实现方式，比如管道、消息队列等
linux进程间通信
10-04
01-04.pdf 文件可能包含更深入的Linux进程间通信教程，建议详细阅读以获取更多信息。通过学习这些概念，开发者可以创建出能够充分利用多核处理器、实现高效协作的复杂系统。在实际开发中，合理利用这些通信机制，...
windows 与linux 进程间通信区别
06-01
适合学习进程间通信机制，对比windows、linux两大主流操作系统，讲解很好
一篇文章了解Linux下进程相关知识
qq_54017644的博客
04-25 2462
1、什么是程序，什么是进程，有什么区别？ 程序是静态的概念，进程是动态的概念。gcc a.c -o a，a就是一个程序，存在于硬盘中，当a跑起来之后，系统中就多了一个进程，进程就是跑起来的程序。 2、什么是进程标识符？ 每个进程都有唯一的非负整数表示唯一ID，叫做pid,类似进程的身份证 pid = 0,交换进程，作用是进程调度 pid = 1,init进程，作用是系统初始化 用top来查看进程的pid以及占用cup，以评估程序好坏。 #include <stdio.h> #include
LINUX PID 1 和 SYSTEMD
weixin_36841920的博客
03-04 3002
要说清 Systemd，得先从Linux操作系统的启动说起。Linux 操作系统的启动首先从 BIOS 开始，然后由 Boot Loader 载入内核，并初始化内核。内核初始化的最后一步就是启动 init 进程。这个进程是系统的第一个进程，PID 为 1，又叫超级进程，也叫根进程。它负责产生其他所有用户进程。所有的进程都会被挂在这个进程下，如果这个进程退出了，那么所有的进程都被 kill 。如果一...
【操作系统】之进程管理
distant_Rove666的博客
08-25 834
进程：是程序的一次执行过程，是一个动态的概念，每次执行都不一样。并发执行：是一个宏观的概念，在微观上某一时刻，每个CPU时间只有一个进程在执行，当执行的速度足够快，人们会认为是在并发执行。fork()------用来创建一个新进程，其返回值意义如下：=0-----在子进程中>0-----在父进程中，返回值为子进程的id值，是进程的唯一标识符...
while(pid1 = fork()== -1);直接分号，循环语句为空
2puT
05-27 2929
这个一般是在多线程当中用的。 比如说线程A 在执行一系列操作之后对变量进行修改。 线程B 需要确定在执行下面的句子时某一变量是否已经满足了要求 比如说 一个程序有两个线程，全局变量 bool flag = false; 线程A的代码如下： { 。。。//执行了一堆代码，可以将flag设置为true了 flag = true; } 线程B的代

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

dz小伟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值