谈谈进程间通信的几种方式？

最新推荐文章于 2024-05-08 15:53:19 发布
最新推荐文章于 2024-05-08 15:53:19 发布
阅读量8.6k 收藏 66
点赞数 17
分类专栏： Linux Linux二三事 文章标签： 进程间通信之管道 进程间通信之命名管道 msg sem
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ONEDAY_789/article/details/72887374
版权

一.为什么进程间需要通信？
1).数据传输
一个进程需要将它的数据发送给另一个进程;
2).资源共享
多个进程之间共享同样的资源;
3).通知事件
一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件;
4).进程控制
有些进程希望完全控制另一个进程的执行(如Debug进程)，该控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变。
基于以上几个原因，所以就有了进程间通信的概念，那仫进程间通信的原理是什仫呢？目前有哪几种进程间通信的机制？他们是如何实现进程间通信的呢？在这篇文章中我会就这几个问题进行详细的讲解。

二.进程间通信的原理
每个进程各自有不同的用户地址空间,任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核,在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信机制。
主要的过程如下图所示：
进程间通信

三.进程间通信的几种方式
1.管道(pipe)
管道又名匿名管道，这是一种最基本的IPC机制，由pipe函数创建：

#include <unistd.h>
int pipe(int pipefd[2]);

返回值：成功返回0，失败返回-1；
调用pipe函数时在内核中开辟一块缓冲区用于通信,它有一个读端，一个写端：pipefd[0]指向管道的读端，pipefd[1]指向管道的写端。所以管道在用户程序看起来就像一个打开的文件,通过read(pipefd[0])或者write(pipefd[1])向这个文件读写数据，其实是在读写内核缓冲区。
使用管道的通信过程：
one
two
three

1.父进程调用pipe开辟管道,得到两个文件描述符指向管道的两端。
2.父进程调用fork创建子进程,那么子进程也有两个文件描述符指向同一管道。
3.父进程关闭管道读端,子进程关闭管道写端。父进程可以往管道里写,子进程可以从管道里读,管道是用环形队列实现的,数据从写端流入从读端流出,这样就实现了进程间通信。

管道出现的四种特殊情况：
1.写端关闭，读端不关闭；
那么管道中剩余的数据都被读取后,再次read会返回0,就像读到文件末尾一样。
2.写端不关闭，但是也不写数据，读端不关闭；
此时管道中剩余的数据都被读取之后再次read会被阻塞，直到管道中有数据可读了才重新读取数据并返回；
3.读端关闭，写端不关闭；
此时该进程会收到信号SIGPIPE，通常会导致进程异常终止。
4.读端不关闭，但是也不读取数据，写端不关闭；
此时当写端被写满之后再次write会阻塞，直到管道中有空位置了才会写入数据并重新返回。
使用管道的缺点：
1.两个进程通过一个管道只能实现单向通信，如果想双向通信必须再重新创建一个管道或者使用sockpair才可以解决这类问题；
2.只能用于具有亲缘关系的进程间通信，例如父子，兄弟进程。
一个简单的关于管道的例子：
代码实现如下：

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

int main()
{
    int _pipe[2]={0,0};
    int ret=pipe(_pipe);  //创建管道
    if(ret == -1)
    {
        perror("create pipe error");
        return 1;
    }
    printf("_pipe[0] is %d,_pipe[1] is %d\n",_pipe[0],_pipe[1]);
    pid_t id=fork();     //父进程fork子进程
    if(id < 0)
    {
        perror("fork error");
        return 2;
    }
    else if(id == 0)  //child,写
    {
        printf("child writing\n");
        close(_pipe[0]);
        int count=5;
        const char *msg="i am from XATU";
        while(count--)
        {
            write(_pipe[1],msg,strlen(msg));
            sleep(1);
        }
        close(_pipe[1]);
        exit(1);
    }
    else  //father,读
    {
        printf("father reading\n");
        close(_pipe[1]);
        char msg[1024];
        int count=5;
        while(count--)
        {
            ssize_t s=read(_pipe[0],msg,sizeof(msg)-1);
            if(s > 0){
                msg[s]='\0';
                printf("client# %s\n",msg);
            }
            else{
                perror("read error");
                exit(1);
            }
        }
        if(waitpid(id,0,NULL) != -1){
            printf("wait success\n");
        }
    }
    return 0;
}

pipe的结果展示

点击此处查看源码

2.命名管道(FIFO)
上一种进程间通信的方式是匿名的，所以只能用于具有亲缘关系的进程间通信，命名管道的出现正好解决了这个问题。FIFO不同于管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存储文件系统中。命名管道是一个设备文件，因此即使进程与创建FIFO的进程不存在亲缘关系，只要可以访问该路径，就能够通过FIFO相互通信。
命名管道的创建与读写：
1).是在程序中使用系统函数建立命名管道；
2).是在Shell下交互地建立一个命名管道，Shell方式下可使用mknod或mkfifo命令来创建管道，两个函数均定义在头文件sys/stat.h中；

       #include <sys/types.h>
       #include <sys/stat.h>
       #include <fcntl.h>
       #include <unistd.h>
       int mknod(const char *pathname, mode_t mode, dev_t dev);

       #include <sys/types.h>
       #include <sys/stat.h>
       int mkfifo(const char *pathname, mode_t mode);

返回值：都是成功返回0，失败返回-1；
path为创建的命名管道的全路径名；
mod为创建的命名管道的模式，指明其存取权限；
dev为设备值，该值取决于文件创建的种类，它只在创建设备文件时才会用到；
mkfifo函数的作用：在文件系统中创建一个文件，该文件用于提供FIFO功能，即命名管道。
命名管道的特点：
1.命名管道是一个存在于硬盘上的文件，而管道是存在于内存中的特殊文件。所以当使用命名管道的时候必须先open将其打开。
2.命名管道可以用于任何两个进程之间的通信，不管这两个进程是不是父子进程，也不管这两个进程之间有没有关系。
一个简单的关于命名管道的例子：
代码实现如下：
server.c

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

void testserver()
{
    int namepipe=mkfifo("myfifo",S_IFIFO|0666);  //创建一个存取权限为0666的命名管道
    if(namepipe == -1){
        perror("mkfifo error");
        exit(1);
    }
    int fd=open("./myfifo",O_RDWR);  //打开该命名管道
    if(fd == -1){
        perror("open error");
        exit(2);
    }
    char buf[1024];
    while(1)
    {
        printf("sendto# ");
        fflush(stdout);
        ssize_t s=read(0,buf,sizeof(buf)-1); //从标准输入获取消息
        if(s > 0){
            buf[s-1]='\0';     //过滤掉从标准输入中获取的换行
            if(write(fd,buf,s) == -1){   //把该消息写入到命名管道中
                perror("write error");
                exit(3);
            }
        }
    }
    close(fd);
}

int main()
{
    testserver();
    return 0;
}

client.c

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

void testclient()
{
    int fd=open("./myfifo",O_RDWR);
    if(fd == -1){
        perror("open error");
        exit(1);
    }
    char buf[1024];
    while(1){
        ssize_t s=read(fd,buf,sizeof(buf)-1);
        if(s > 0){
            printf("client# %s\n",buf);
        }
        else{  //读失败或者是读取到字符结尾
            perror("read error");
            exit(2);
        }
    }
    close(fd);
}

int main()
{
    testclient();
    return 0;
}

命名管道

点击此处查看源码

3.消息队列(msg)
对于消息队列的描述可以参考我的另外一篇博客：

进程间通信之消息队列

4.信号量(sem)
什仫是信号量？
信号量的本质是一种数据操作锁，用来负责数据操作过程中的互斥，同步等功能。
信号量用来管理临界资源的。它本身只是一种外部资源的标识，不具有数据交换功能，而是通过控制其他的通信资源实现进程间通信。 可以这样理解，信号量就相当于是一个计数器。当有进程对它所管理的资源进行请求时，进程先要读取信号量的值：大于0，资源可以请求；等于0，资源不可以用，这时进程会进入睡眠状态直至资源可用。
当一个进程不再使用资源时，信号量+1(对应的操作称为V操作)，反之当有进程使用资源时，信号量-1(对应的操作为P操作)。对信号量的值操作均为原子操作。
为什仫要使用信号量？
为了防止出现因多个程序同时访问一个共享资源而引发的一系列问题，我们需要一种方法，它可以通过生成并使用令牌来授权，在任一时刻只能有一个执行线程访问代码的临界区域。
什仫是临界区？什仫是临界资源？
临界资源：一次只允许一个进程使用的资源。
临界区：访问临界资源的程序代码片段。
信号量的工作原理？
P(sv)：如果sv的值大于零，就给它减1；如果它的值为零，就挂起该进程的执行等待操作；
V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给它加1；
举个例子，就是两个进程共享信号量sv，一旦其中一个进程执行了P(sv)操作，它将得到信号量，并可以进入临界区，使sv减1。而第二个进程将被阻止进入临界区，因为当它试图执行P(sv)时，sv为0，它会被挂起以等待第一个进程离开临界区域并执行V(sv)释放信号量，这时第二个进程就可以恢复执行了。
与信号量有关的函数操作？
1).创建/获取一个信号量集合

       #include <sys/types.h>
       #include <sys/ipc.h>
       #include <sys/sem.h>
       int semget(key_t key, int nsems, int semflg);

返回值：成功返回信号量集合的semid，失败返回-1。
key:可以用函数key_t ftok(const char *pathname, int proj_id);来获取。
nsems:这个参数表示你要创建的信号量集合中的信号量的个数。信号量只能以集合的形式创建。
semflg:同时使用IPC_CREAT和IPC_EXCL则会创建一个新的信号量集合。若已经存在的话则返回-1。单独使用IPC_CREAT的话会返回一个新的或者已经存在的信号量集合。
2).信号量结合的操作

       #include <sys/types.h>
       #include <sys/ipc.h>
       #include <sys/sem.h>
       int semop(int semid, struct sembuf *sops, unsigned nsops);
       int semtimedop(int semid, struct sembuf *sops, unsigned nsops,struct timespec *timeout);

返回值：成功返回0，失败返回-1；
semid：信号量集合的id；

struct sembuf *sops;
struct sembuf
{
            unsigned short sem_num;  /* semaphore number */
           short          sem_op;   /* semaphore operation */
           short          sem_flg;  /* operation flags */
}

sem_num：为信号量是以集合的形式存在的，就相当于所有信号在一个数组里面，sem_num表示信号量在集合中的编号；
sem_op：示该信号量的操作(P操作还是V操作)。如果其值为正数，该值会加到现有的信号内含值中。通常用于释放所控资源的使用权；如果sem_op的值为负数，而其绝对值又大于信号的现值，操作将会阻塞，直到信号值大于或等于sem_op的绝对值。通常用于获取资源的使用权 。
sem_flg:信号操作标志，它的取值有两种：IPC_NOWAIT和SEM_UNDO。

IPC_NOWAIT:对信号量的操作不能满足时，semop()不会阻塞，而是立即返回，同时设定错误信息；
SEM_UNDO: 程序结束时(不管是正常还是不正常)，保证信号值会被设定；

nsops:表示要操作信号量的个数。因为信号量是以集合的形式存在，所以第二个参数可以传一个数组，同时对一个集合中的多个信号量进行操作。
semop()调用之前的值。这样做的目的在于避免程序在异常的情况下结束未将锁定的资源解锁(死锁)，造成资源永远锁定。
3).int semctl(int semid,int semnum,int cmd,...);
semctl()在semid标识的信号量集合上，或者该信号量集合上第semnum个信号量上执行cmd指定的控制命令。根据cmd不同，这个函数有三个或四个参数，当有第四个参数时，第四个参数的类型是union。

union semun{
int val;   //使用的值
struct semid_ds *buf;  //IPC_STAT、IPC_SET使用缓存区
unsigned short *array; //GETALL、SETALL使用的缓存区
struct seminfo *__buf; //IPC_INFO(linux特有)使用缓存区
};

返回值：成功返回0，失败返回-1；
semid:信号量集合的编号。
semnum:信号量在集合中的标号。
4).信号量类似消息队列也是随内核的，除非用命令才可以删除该信号量
ipcs -s //查看创建的信号量集合的个数
ipcrm -s semid //删除一个信号量集合
一个简单的关于信号量的例子？
父进程中打印BB，子进程中打印AA。利用信号量机制使得AA和BB之间不出现乱序。此时的显示器就是临界资源，我们需要在父子进程的临界区进行加锁。

comm.h

#ifndef _COMM_H_
#define _COMM_H_
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#include<sys/types.h>
#include<sys/wait.h>

#define PATHNAME "."
#define PROJID 0x6666

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) */
};

int CreateSemSet(int num);//创建信号量
int GetSemSet();       //获取信号量
int InitSem(int sem_id,int which);
int P(int sem_id,int which); //p操作
int V(int sem_id,int which); //v操作
int DestroySemSet(int sem_id);//销毁信号量

#endif //_COMM_H_

comm.c

#include"comm.h"

static commSemSet(int num,int flag)
{
    key_t key=ftok(PATHNAME,PROJID);
    if(key == -1)
    {
        perror("ftok error");
        exit(1);
    }
    int sem_id=semget(key,num,flag);
    if(sem_id == -1)
    {
        perror("semget error");
        exit(2);
    }
    return sem_id;
}

int CreateSemSet(int num)
{
    return commSemSet(num,IPC_CREAT|IPC_EXCL|0666);
}

int InitSem(int sem_id,int which)
{
    union semun un;
    un.val=1;
    int ret=semctl(sem_id,which,SETVAL,un);
    if(ret < 0)
    {
        perror("semctl");
        return -1;
    }
    return 0;
}

int GetSemSet()
{
    return commSemSet(0,IPC_CREAT);
}

static int SemOp(int sem_id,int which,int op)
{
    struct sembuf buf;
    buf.sem_num=which;
    buf.sem_op=op;
    buf.sem_flg=0; //
    int ret=semop(sem_id,&buf,1);
    if(ret < 0)
    {
        perror("semop error");
        return -1;
    }
    return 0;
}

int P(int sem_id,int which)
{
    return SemOp(sem_id,which,-1);
}

int V(int sem_id,int which)
{
    return SemOp(sem_id,which,1);
}

int DestroySemSet(int sem_id)
{
    int ret=semctl(sem_id,0,IPC_RMID);
    if(ret < 0)
    {
        perror("semctl error");
        return -1;
    }
    return 0;
}

SemSet.c

#include"comm.h"

void testSemSet()
{
    int sem_id=CreateSemSet(1);  //创建信号量
    InitSem(sem_id,0);
    pid_t id=fork();
    if(id < 0){
        perror("fork error");
        exit(1);
    }
    else if(id == 0){   //child，打印AA
        printf("child is running,pid=%d,ppid=%d\n",getpid(),getppid());
        while(1)
        {
            P(sem_id,0);  //p操作，信号量的值减1
            printf("A");
            usleep(10031);
            fflush(stdout);
            printf("A");
            usleep(10021);
            fflush(stdout);
            V(sem_id,0); //v操作，信号量的值加1
        }
    }
    else   //father，打印BB
    {
        printf("father is running,pid=%d,ppid=%d\n",getpid(),getppid());
        while(1)
        {
            P(sem_id,0);
            printf("B");
            usleep(10051);
            fflush(stdout);
            printf("B");
            usleep(10003);
            fflush(stdout);
            V(sem_id,0);
        }
        wait(NULL);
    }
    DestroySemSet(sem_id);
}

int main()
{
    testSemSet();
    return 0;
}

进程间通信之信号量

点击此处查看源码

5.共享内存(shm)
共享内存的原理图：
共享内存的原理图

与共享内存有关的函数：
1). 创建共享内存

    #include <sys/ipc.h>
    #include <sys/shm.h>
    int shmget(key_t key, size_t size, int shmflg);

返回值：成功返回共享内存的id，失败返回-1；
key：和上面介绍的信号量的semget函数的参数key一样；
size：表示要申请的共享内存的大小，一般是4k的整数倍；
flags：IPC_CREAT和IPC_EXCL一起使用，则创建一个新的共享内存，否则返回-1。IPC_CREAT单独使用时返回一个共享内存，有就直接返回，没有就创建。
2).挂接函数

void *shmat(int shmid);

返回值：返回这块内存的虚拟地址；
shmat的作用是将申请的共享内存挂接在该进程的页表上，是将虚拟内存和物理内存相对应；
3).去挂接函数

 int shmdt(const void *shmaddr);

返回值：失败返回-1；
shmdt的作用是去挂接，将这块共享内存从页表上剥离下来，去除两者的映射关系；
shmaddr:表示这块物理内存的虚拟地址。
4).int shmctl(int shmid,int cmd,const void* addr);
shmctl用来设置共享内存的属性。当cmd是IPC_RMID时可以用来删除一块共享内存。
5).共享内存类似消息队列和信号量，它的生命周期也是随内核的，除非用命令才可以删除该共享内存；
ipcs -m //查看创建的共享内存的个数
ipcrm -m shm_id //删除共享内存
一个简单的关于共享内存的例子：
利用共享内存实现在serve这个进程中向共享内存中写入数据A，从client读出数据。

comm.h

#ifndef __COMM__
#define __COMM__

#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<unistd.h>

#define PATHNAME "."
#define PROCID 0x6666
#define SIZE 4096*1

int CreatShm();
int GetShm();
//int AtShm();
//int DtShm();
int DestroyShm(int shm_id);

#endif

comm.c

#include"comm.h"

static int CommShm(int flag)
{
    key_t key=ftok(PATHNAME,PROCID);
    if(key < 0)
    {
        perror("ftok");
        return -1;
    }
    int shm_id=shmget(key,SIZE,flag);
    if(shm_id < 0)
    {
        perror("shmget");
        return -2;
    }
    return shm_id;
}

int CreatShm()
{
    return CommShm(IPC_CREAT|IPC_EXCL|0666);
}

int GetShm()
{
    return CommShm(IPC_CREAT);
}

//int AtShm();
//int DtShm();

int DestroyShm(int shm_id)
{
    int ret=shmctl(shm_id,IPC_RMID,NULL);
    if(ret < 0)
    {
        perror("shmctl");
        return -1;
    }
    return 0;
}

server.c

#include"comm.h"

void testserver()
{
    int shm_id=CreatShm();
    printf("shm_id=%d\n",shm_id);
    char *mem=(char *)shmat(shm_id,NULL,0);
    while(1)
    {
        sleep(1);
        printf("%s\n",mem);
    }
    shmdt(mem);
    DestroyShm(shm_id);
}

int main()
{
    testserver();
    return 0;
}

client.c

#include"comm.h"

void testclient()
{
    int shm_id=GetShm();
    char *mem=(char *)shmat(shm_id,NULL,0);
    int index=0;
    while(1)
    {
        sleep(1);
        mem[index++]='A';
        index %= (SIZE-1);
        mem[index]='\0';
    }
    shmdt(mem);
    DestroyShm(shm_id);
}

int main()
{
    testclient();
    return 0;
}

点击此处查看源码

共享内存的特点：
共享内存是这五种进程间通信方式中效率最高的。但是因为共享内存没有提供相应的互斥机制，所以一般共享内存都和信号量配合起来使用。
为什仫共享内存的方式比其他进程间通信的方式效率高？
消息队列，FIFO，管道的消息传递方式一般为 ：
1).服务器获取输入的信息；
2).通过管道，消息队列等写入数据至内存中，通常需要将该数据拷贝到内核中；
3).客户从内核中将数据拷贝到自己的客户端进程中；
4).然后再从进程中拷贝到输出文件；
上述过程通常要经过4次拷贝，才能完成文件的传递。
而共享内存只需要：
1).输入内容到共享内存区
2).从共享内存输出到文件
上述过程不涉及到内核的拷贝，这些进程间数据的传递就不再通过执行任何进入内核的系统调用来传递彼此的数据，节省了时间，所以共享内存是这五种进程间通信方式中效率最高的。

在这里就分享结束了~~~

Cassie612
关注
  • 17
    点赞
  • 踩
  • 66
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
跨进程的双向通信
shizhonghuo19870328的博客
05-26 630
文章http://blog.csdn.net/shizhonghuo19870328/article/details/53192870 介绍了怎样用aidl 来实现跨进程通信。 但是此种架构只能实现从客户端到服务端的传递。 没有服务端向客户端传递的功能。 并且直接在服务端实现aidl  interface， 不利于程序解耦。 下面介绍一种实现进程件双向通信的方法。 有两个模块， 模块Voi
共享内存+互斥量实现linux进程间通信 分类： Linux ...
weixin_30405421的博客
03-26 392
一、共享内存简介 共享内存是进程间通信中高效方便的方式之一。共享内存允许两个或更多进程访问同一块内存，就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针，两个进程可以对一块共享内存进行读写。 共享内存并未提供进程同步机制，使用共享内存完成进程间通信时，需要借助互斥量或者信号量来完成进程的同步。这里说一下互斥量与信号量的区别。互斥量用于线程的互斥，...
通过共享内存，实现两个进程A,B之间的通信
wangshiqueque的专栏
07-30 6295
进程A： #include      #include      #include      #include      #include    #include    #include      #define SHM_SIZE    4096  #define SHM_MODE    (SHM_R | SHM_W) /* user read/write *
进程间通信的7种方式你都了解吗
最新发布
2401_84149733的博客
05-08 633
（1）管道是特殊类型的文件，在满足先入先出的原则条件下可以进行读写，但不能进行定位读写。（2）匿名管道是单向的，只能在有亲缘关系的进程间通信；有名管道以磁盘文件的方式存在，可以实现本机任意两个进程通信。（3）无名管道阻塞问题：无名管道无需显示打开，创建时直接返回文件描述符，在读写时需要确定对方的存在，否则将退出。如果当前进程向无名管道的一端写数据，必须确定另一端有某一进程。如果写入无名管道的数据超过其最大值，写操作将阻塞，如果管道中没有数据，读操作将阻塞，如果管道发现另一端断开，将自动退出。
编写一个应用程序，要求包含3个进程，每个进程中包含2个线程，采用共享内存、套接字、信号量等通信方式实现进程间的通信、同步、互斥操作
goal_achieving的博客
11-19 282
导入库函数声明所有线程函数3个进程，每个进程中包含2个线程。
进程通信之--匿名管道双向通信
bood123的专栏
04-20 1260
学习了m_buddy的https://blog.csdn.net/m_buddy/article/details/72867107Windows进程通信——匿名管道 发现建了一个匿名管道，双向通信存在问题，建了两个匿名管道 匿名管道是在本地机器上使用，实现父进程和子进程之间的通信的进程通信机制。需要注意两点： （1）就是在本地机器上，这是因为匿名管道不支持跨网络之间的两个进程之间的通信 ...
谈谈Android的三种网络通信方式
08-31
Android平台有三种网络接口可以使用，他们分别是：java.net.*(标准Java接口)、Org.apache接口和Android.net.*(Android网络接口)。本文详细的介绍，有兴趣的可以了解一下。
全面的谈谈目前智能家居布线方式有哪几种
07-19
本文主要讲了智能家居布线的几种方式，一起来学习一下
Vue.js 父子组件通信的十种方式
01-19
面试官：Vue 中父子组件通信有哪些方式？ 自己先想一分钟。 无可否认，现在无论大厂还是小厂都已经用上了Vue.js 框架，简单易上手不说，教程详尽，社区活跃，第三方套件还多。真的是前端开发人员必备技能。而且在...
简单谈谈Java 中的线程的几种状态
08-25
主要介绍了简单谈谈Java 中的线程的几种状态的相关资料,需要的朋友可以参考下
进程间双向通信--sockpair
weixin_34232744的博客
05-23 359
sockpair是一个套接字，可以用于网络通信，也可用于本机内进程间通信。sockpair类似于管道，只不过管道是用于单向通信的，只能一方读，一方写，。而想要用于进程间双向通信，就要pipe两次，创建两个管道。sockpair直接就可以实现进程间双向通信。1#include<stdio.h> 2#include<unistd.h> ...
进程间通信
06-22
单机windows系统下两进程之间相互通信
Linux进程通信代码
01-02
LinuxIPC通信代码，包含有匿名管道，命名管道，消息队列，信号量，信号，共享内存
进程间通信详解
向未来❀去探索 的博客
06-26 9573
进程间通信详解(命名管道，匿名管道，共享内存)
操作系统之进程通信 (八) --- 共享存储、管道通信、消息传递...
qq_19018277的博客
08-04 9800
进程通信 进程通信的概念与方法 顾名思义，进程通信就是指进程之间的信息交换。 进程是分配系统资源的单位(包括内存地址空间)，因此各进程拥有的内存地址空间相互独立，而且为了保证安全，一个进程不能直接访问另外一个进程的地址空间。 但是，在很多情况下，进程之间的信息交换又是必须的，如 某些APP的分享到微信朋友圈功能，这些APP就需要和微信进行进程通信。所以，为了保证进程间的安全通信，操作系统提供了一...
进程间通信——消息传递（管道）
业精于勤，而荒于嬉； 行成于思，而毁于随。
03-02 2080
【申明：本文仅限于自我归纳总结和相互交流，有纰漏还望各位指出。 联系邮箱：Mr_chenping@163.com】 本篇是IPC开篇吧，最近开始研读进程间通信，感知Linux博大精深啊，一步一步来吧。今天先说最原始的通信方式管道，管道分两种，无名管道pipe和有名管道fifo。本篇参考UNIX网络编程之进程间通信相关源码，首先我们来了解无名管道pipe。 无名管道特点： 一、半双工的，数据只
Linux 系统应用编程——进程间通信（上）
知秋一叶
01-08 9739
现在再Linux应用较多的进程间通信方式主要有以下几种： 1）无名管道（pipe）及有名管道（fifo）：无名管道可用于具有亲缘关系进程间的通信；有名管道除具有管道相似的功能外，它还允许无亲缘关系进程使用； 2）信号（signal）：信号是在软件层次上对中断机制的一种模拟，它是比较复杂的通信方式，用于通知进程某事件发生。一个进程收到一个信号与处理器收到
进程间通信那种效率最高_几种进程间的通信方式 比较
github_38595636的博客
03-14 2687
# 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。 # 有名管道 (named pipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。 # 信号量( semophore ) ： 信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。 # 消息队列
linux下的进程通信代码,Linux之------进程间通信(示例代码)
weixin_31083901的博客
05-01 361
现在Linux使用的进程间通信方式包括：1、无名管道(pipe)和有名管道(FIFO)2、信号(signal)3、消息队列4、共享内存5、信号量6、套接字(socket)管道通信：数据被一个进程读出后，将被从管道中删除，其它读进程将不能再读到这些数据。管道提供了简单的流控制机制，进程试图读空管道时，进程将阻塞。同样，管道已经满时，进程再试图向管道写入数据，进程将阻塞。管道包括无名管道和有名管道两种...
谈谈人工智能的几种归并策略
03-31
人工智能的归并策略可以分为以下几种： 1. 基于任务的归并策略：将人工智能应用按照任务进行分类。例如，将人工智能应用分为语音识别、图像识别、自然语言处理等。 2. 基于技术的归并策略：将人工智能应用按照技术...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值