Linux学习——进程间通信（IPC）（二）

最新推荐文章于 2024-06-21 20:56:56 发布
最新推荐文章于 2024-06-21 20:56:56 发布
阅读量609 收藏 30
点赞数 22
文章标签： linux 学习 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70569293/article/details/136778397
版权

六、信号量（Semaphore）

        同步和互斥：在多任务的操作系统下，多个进程会同时运行，并且一些进程间可能会存在一定的关联。多个进程可能为了完成同一个任务相互协作，这就形成了进程间的同步关系；在不同进程间为了争夺有限的系统资源（硬件或软件资源）会进入竞争状态，这就是进程间的互斥关系。

        进程间的互斥、同步关系存在的根源在于临界资源。临界资源是在同一时刻只允许有限个（通常一个）进程可以访问（读）或修改（写）的资源，通常包括硬件资源（处理器、内存、存储器以及其他外围设备等）和软件资源（共享代码段、共享结构和变量等）。访问临界资源的代码叫做临界区，临界区本身也会成为临界资源。信号量是用来解决进程间的同步与互斥问题的一种进程间的通信机制，包括一个称为信号量的变量在该信号量下等待资源的进程等待序列，以及对信号量进行的两个原子操作（P/V操作）。其中，信号量对应于某一种资源，取一个非负的整型值。信号量值（常用sem_id表示）指的是当前可用的该资源的数量，若等于0则意味着目前没有可用的资源。

PV原子操作的具体定义如下：

        P操作：如果有可用的资源（信号量值>0），则此操作所在的进程占用一个资源（此时信号量值-1，进入临界代码区）；如果没有可用的资源（信号量值=0），则此操作所在的进程被阻塞直到系统将资源分配给该进程（进入等待序列，一直等到资源轮到该进程）；

        V操作：如果在该信号量的等待队列中有进程在等待资源，则唤醒一个阻塞进程；如果没有等待他，则释放一个资源（即信号量值+1）；

总而言之，P操作负责分配资源，没有资源的时候就等着（进入阻塞队列）。V操作负责释放资源，在阻塞队列不为空的时候唤醒某个进程进入临界区。

在Linux系统中，使用信号量通常分为以下4个步骤：

        （1）创建信号量或获得在系统中已存在的信号量，此时需要调用semget()函数。不同进程通过使用同一个信号量键值来获得同一个信号量；

        （2）初始化信号量，此时使用semctl()函数的AETVAL操作。当使用互斥信号量时，通常将信号量初始化为1；

        （3）进行信号量的PV操作，此时，调用semop()函数。这一步是实现进程间的同步和互斥的的核心工作部分；

        （4）如果不需要信号量，则从系统中删除他，此时使用semctl()函数的IPC_RMID操作。需要注意的是，在程序中不应该出现对已经被删除的信号量的操作；           

ftok()获取IPC关键字 

#include<sys/types.h>

#include<sys/ipc.h>

key_t ftok(const char *pathname,int proj_id);

该函数根据pathname指定的文件或目录的索引节点号和proj_id计算并返回一个key_t类型的ID值，如果失败则返回-1；

pathname：系统中必须存在的文件或文件夹路径，会使用该文件的索引节点；

proj_id：用户指定的子序号，他是一个8bit的整数，取值范围是1~255；

        共享内存、消息队列、信号量三种进程间的通信方式都需要key_t类型的关键字ID值 ，就像我们需要一个唯一的身份证号来区分一样，有时我们可以直接指定一个固定的整数值作为该ID值，但是通常情况下会通过ftok()函数获取该值。在一般的UNIX系统中，该函数是将文件的索引节点号取出，前面加上子序号得到key_t的返回值。如指定文件的索引节点号为65538，换成16进制为0x010002，这时我们指定的ID值为38，换成16进制为0x26，则最后key_t的返回值为0x26010002。查询文件索引节点号的方法是：ls -i filename     

semget()函数创建或者获取信号量

#include<sys/types.h>

#include<sys/ipc.h>

#include<sys/sem.h>

int semget(key_t key,int nsems,int semflg);

该函数用来创建一个信号集，或者获取已经存在的信号集。成功返回信号量集的标识符，失败返回-1；

key：ftok()的返回值，

nsems：指定需要的信号量数目，它的值几乎总为1；

semflg：用于指定信号量集合的访问权限和其他选项，通常使用位掩码来指定不同的选项；

semctl()函数

 #include<sys/types.h>

#include<ysy/ipc.h>

#include<sys/sem.h>

int semctl(int semid,int semun,int cmd,...);

该函数用来初始化信号集，或者删除信号集。成功返回一个正数，失败返回-1；

semid：semget()函数返回的信号量键值；

semun：是操作信号在信号集中的编号，第一个信号是0；

cmd：是在semid指定的信号量集合上执行此命令，可以是：

                SETVAL：设置信号量集合中的一个单独的信号量的值，此时需要传入第四个参数；

                IPC_RMID：从系统中删除该信号量集合；

                IPC_SEAT：对此集合取semid_ds结构，并存放在由arg.buf指向的结构中；

第四个参数是可选的，如果使用该参数，则其类型是semun，它是多个特定明命令参数的联合，该联合不在任何系统头文件中定义，需要我们自己在代码中定义：

union semun

{

        int                val;

        struct semid_ds        *buf;

        unsigned short          *array;

        struct seminfo           *__buf;

};

 

semop()函数

#include<sys/types.h>

#include<sys/ipc.h>

#include<sys/sem.h>

int semop(int semid,struct sembuf* sops,unsigned nsops);

PV操作。成功执行，返回0；失败返回-1，并设置errno错误信息；

semid：是semget()函数返回的信号量键值；

sops：是一个指针，指向一个信号量操作数组。信号量操作由结构体sembuf结构，表示如下：

        struct sembuf        

        {

                unsigned short sem_num;// 操作信号在信号集中的编号，第一个信号的编号是0，最后一个编号是nsems-1

                short sem_op;   // 操作为负——P操作，其绝对值大于信号的现有值，操作将会阻塞，直到信号值大于或等于sem_op的绝对值。通常用于获取资源的使用权；操作为正——V操作，该值会加到现有的信号内值上，通常用于释放所控制资源的使用权；为0，如果后面的sem_flag没有设置IPC_NOWAIT，则调用该操作的进程或线程将暂时休眠，直到信号量的值为0，否则进程或线程会返回错误EAGAIN；

                short sem_flg;// 操作标识符，IPC_NOWAIT：对信号的操作不能满足时，semop()不会阻塞，并立即返回，同时设定错误信息；SEM_UNDO：程序结束时，保证信号值会被重设为semop()调用前的值，避免程序在异常情况下结束时未解锁锁定的资源，造成死锁；

        }；

nsops：信号操作结构的数量，大于等于1；

         下面通过PV操作来实现父子进程同步运行的例子。在初始化信号量时将信号量初始值设为0，如果父进程先运行的话将会调用semaphore_p(semid),这时因为资源为0所以父进程会堵塞。之后子进程会执行semaphore_v(semid)将资源+1，之后父进程就可以运行了

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

#define FTOK_PATH                       "/lizhao/APUE"

#define FTOK_PROJID                     0x22

union semun
{
        int                                     val;
        struct semid_ds         *buf;
        unsigned short          *array;
};


int semaphore_init(void);
int semaphore_p(int semid);
int semaphore_v(int semid);
void semaphore_term(int semid);


int main(int argc,char **argv)
{
        int                     semid;
        pid_t           pid;
        int                     i;

        if( (semid = semaphore_init()) < 0 )
        {
                printf("semaphore initial failure : %s\n",strerror(errno));
                return -1;
        }
        if( (pid = fork()) < 0 )
        {
                printf("fork() failure : %s\n",strerror(errno));
                return -2;
        }

        /*child process*/
        else if( 0 == pid )
        {
                printf("Child process start running and  do something now...\n");
                sleep(3);
                printf("Child process do something over...\n");
                semaphore_v(semid);

                sleep(1);
                printf("child process exit now\n");
                exit(0);
        }


        /*前面的semaphore_init()函数里将信号量的值设置为0，如果这时候父进程先执行的话，P操作会阻塞；
         * 直到子进程执行V操作后，父进程的P操作才能返回继续执行*/

        printf("Parent process P operator wait child process over\n");

        semaphore_p(semid);

        printf("Parent process destroy semaphore and exit\n");
        sleep(2);
        printf("Child process exit amd ");
        semaphore_term(semid);
        return 0;
}

int semaphore_init(void)
{
        key_t                   key;
        int                             semid;
        union semun             sem_union;

        if( (key = ftok(FTOK_PATH,FTOK_PROJID)) < 0 )
        {
                printf("ftok() get IPC token failure : %s\n",strerror(errno));
                return -1;
        }

        semid = semget(key,1,IPC_CREAT|0644);
        if( semid < 0 )
        {
                printf("semget() get semid failure : %s\n",strerror(errno));
                return -2;
        }

        sem_union.val = 0;
        if( semctl(semid,0,SETVAL,sem_union) < 0 )
        {
                printf("semctl() set initial value failure : %s\n",strerror(errno));
                return -3;
        }

        printf("Semaphore get key_t[0x%x] and semid[%d]\n",key,semid);
        return semid;
}


void semaphore_term(int semid)
{
        union semun                     sem_union;

        if( semctl(semid,0,IPC_RMID,sem_union) < 0 )
        {
                printf("semctl() delete semaphore ID failure : %s\n",strerror(errno));
        }

        return ;
}


int semaphore_p(int semid)
{
        struct sembuf           _sembuf;
        _sembuf.sem_num = 0;
        _sembuf.sem_op = -1;
        _sembuf.sem_flg = SEM_UNDO;//  IPC_NOWAIT SEM_UNDO

        if( semop(semid,&_sembuf,1) < 0 )
        {
                printf("semop P operator failure : %s\n",strerror(errno));
                return -1;
        }

        return 0;
}


int semaphore_v(int semid)
{
        struct sembuf           _sembuf;
        _sembuf.sem_num = 0;
        _sembuf.sem_op = 1;
        _sembuf.sem_flg = SEM_UNDO;// IPC_NOWAIT SEM_UNDO 

        if( semop(semid,&_sembuf,1) < 0 )
        {
                printf("semop V operator failure: %s\n",strerror(errno));
                return -1;
        }

        return 0;
}

七、共享内存（Shared Memory）

        共享内存，就是两个或多个进程可以访问同一块内存空间，一个进程对这块空间的内容的修改可为其他县域通信的进程所看到的。显然，为了创建共享内存需要两个步骤：一是在内存划出一块区域作为共享区；二是把这个区域映射到参与通信的各个进程空间。共享内存是最快的IPC形式。一旦建成共享内存，进程就不再通过执行进入内核的系统调用来传递彼此的数据。

共享内存会使用到的函数： 

#include<sys/types.h>

#include<sys/ipc.h>

#include<sys/shm.h>

key_t ftok(const char *pathname,size_t size,int shmflg);//上文已经讲过

/* 该函数用来创建共享内存，成功返回一个非负整数，即该共享内存段的标识码；失败返回-1；*/

int shmget(key_t key,size_t size,int shamflg);

key：ftok()返回的key_t类型的键值；

size：以字节为单位指定需要共享内存的内存容量；

shmflg：是权限标志；

/*该函数用于对共享内存的启用，并把共享内存连接到当前进程的地址空间，调用成功时返回一个指向共享内存第一个字节指针，如果调用失败返回-1*/

void *shmat(int shmid,const void *shmaddr,int shmflg);

shmid：shmget()函数返回的共享内存标识；

shmaddr：指定共享内存连接到当前进程中的地址位置，通常为空，表示让系统来选择共享内存的地址；

shmflg：一组标志位，通常为0；

/* 该函数用于将共享内存从当前进程中分离（并不是删除），使该共享内存对当前进程不再可用。成功返回0，失败返回-1*/

int shmdt(const void *shmaddr)；

shmaddr：是shmat函数返回的地址指针；

/*该函数用于控制共享内存*/

int shmctl（int shmid，int cmd，struct shmid_ds *buf）；

shmid：是shmget()函数返回的共享内存标识符；

cmd：是要采取的操作，他可以采取下面的三个值：

                IPC_STAT：把shmid_ds结构中的数据设置为共享内存的当前关联值，即用共享内存的当前关联值覆盖shmid_ds的值；

                IPC_SET：如果进程有足够的权限，就把共享内存的当前关联值设置为shmid_ds结构中 给出的值；

                IPC_RMID：删除共享内存段；

struct shmid_ds

{

        uid_t                shm_perm.uid；

        uid_t                shm_perm.gid；

        mode_t            shm_perm.mode；

}

 

下面两个进程，使用共享内存的方式共享一个结构体变量的示例，其中shared_mem_write.c用来创建一个student结构体共享内存并更改更新里面的成员内容，而shared_mem_read.c则在另外一个毫无关系的进程中同步访问该结构体里的内容

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


#define FTOK_PATH               "/dev/zero"
#define FTOK_PROJID             0x22

typedef struct st_student
{
        char            name[64];
        int                     age;
}t_student;


int main(int argc,char **argv)
{
        key_t           key;
        int                     shimd;
        int                     i;
        t_student       *student;

        if( (key = (FTOK_PATH,FTOK_PROJID)) < 0 )
        {
                printf("ftok() get IPC token failure : %s\n",strerror(errno));
                return -1;
        }

        shimd = shmget(key,sizeof(t_student),IPC_CREAT|0666);

        if( shimd < 0 )
        {
                printf("shmget() create shared memory failure : %s\n",strerror(errno));
                return -2;
        }

        student = shmat(shimd,NULL,0);
        if( (void *)-1 == student )
        {
                printf("shmat() alloc shared memory failure : %s\n",strerror(errno));
                return -2;
        }

        strncpy(student->name,"zhangsan",sizeof(student->name));
        student->age = 18;

        for(i=0;i<4;i++)
        {
                student->age ++;
                printf("Student '%s' age [%d]\n",student->name,student->age);
                sleep(1);
        }

        shmdt(student);
        shmctl(shimd,IPC_RMID,NULL);
        return 0;
}

 

     

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


#define FTOK_PATH               "/dev/zero"
#define FTOK_PROJID             0x22

typedef struct st_student
{
        char            name[64];
        int                     age;
}t_student;


int main(int argc,char **argv)
{
        key_t           key;
        int                     shimd;
        int                     i;
        t_student       *student;

        if( (key = (FTOK_PATH,FTOK_PROJID)) < 0 )
        {
                printf("ftok() get IPC token failure : %s\n",strerror(errno));
                return -1;
        }

        shimd = shmget(key,sizeof(t_student),IPC_CREAT|0666);

        if( shimd < 0 )
        {
                printf("shmget() create shared memory failure : %s\n",strerror(errno));
                return -2;
        }

        student = shmat(shimd,NULL,0);
        if( (void *)-1 == student )
        {
                printf("shmat() alloc shared memory failure : %s\n",strerror(errno));
                return -2;
        }

        strncpy(student->name,"zhangsan",sizeof(student->name));
        student->age = 18;

        for(i=0;i<4;i++)
        {
                student->age ++;
                printf("Student '%s' age [%d]\n",student->name,student->age);
                sleep(1);
        }

        shmdt(student);
        shmctl(shimd,IPC_RMID,NULL);
        return 0;
}

 

八、消息队列（MQ，Message Queue）

         消息队列提供了一个从一个进程向另外一个进程发送一块数据的方法，每个数据块都被认为是有一个类型，接收者进程接收的数据块可以有不同的类型。每个消息的最大长度是有上限的，每个消息队列的总得字节数是有上限的，系统上消息队列的总数也有一个上限。

MQ的API操作与共享内存几乎是相同的，分为下面四个步骤：

1.创建和访问MQ；

2.发送消息；

3.接受消息；

4.删除MQ；

#include<sys/types.h>

#include<sys/ipc.h>

#include<sys/msg.h>

key_t ftok(const char *pathname,int proj_id);

/*该函数用来创建消息队列ID，成功返回一个非负数，即该共享内存段的标识码，失败返回-1*/

int msgget(key_t key,int msgflg);

key:是ftok()函数的返回值

msgflg：是创建标志；

/*用来发送一个消息，必须要有写消息队列的权限，成功返回0；失败返回-1，并设置errno*/

int msgsnd（int msqid，const void *msgp，size_t msgsz，int msgflg）；

msgid：由msgget()返回的消息队列ID；

msgp：是一个指针，它指向要发送的消息结构体类型的变量。消息结构在两方面受到制约。首先，它必须小于系统规定的上限值；其次，它必须以一个long int 长整数开始，接收者函数将利用这个长整数确定消息的类型，其参考的类型如下：

        typedef struct s_msgbuf        

        {

                long mtype；

                char mtext[512];

        } t_msgbuf;

msgsz:要发送的消息的长度；

msgflg：控制当前消息队列满或达到系统上限将要发生的事情;

/*用来从一个消息队列中接收消息，成功返回实际放到接收缓冲区里去的字符个数，失败返回-1，并设置errno*/

ssize_t msgrcv(int msqid,void *msgp,size_t msgsz,long msgtyp,int msgflg);

msgid:msgget()返回的消息队列ID；

msgp：是一个指针，指向准备接受的消息；

msgsz：msgp指向的消息的长度；

msgtype：是消息的类型，他可以实现接收优先级的简单形式:

                                        msgtype = 0，返回队列第一条信息；

                                        msgtype>0 ,返回队列第一条类型等于msgtype信息；

                                        msgtype<0，返回队列第一条类型小于等于msgtype绝对值的消息；

msgflg：控制队列中没有相应类型的消息可供接收时将要发生的事

/*该函数用于控制消息队列*/

int msgctl（int msqid，int  cmd，struct msqid_ds *buf）；

msqid：消息队列的标识符，是由 msgget() 函数返回 

cmd：要执行的操作类型，可以是以下之一：

        IPC_STAT：获取消息队列的状态信息，并将其存储在 struct msqid_ds 结构体中。

        IPC_SET：设置消息队列的状态信息，通过 struct msqid_ds 结构体中提供的信息进行设置。

        IPC_RMID：从系统中删除消息队列。

buf：一个指向 struct msqid_ds 结构体的指针，用于存储或传递消息队列的状态信息。

示例程序：

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


#define FTOK_PATH               "/dev/zero"
#define FTOK_PROJID             0x22

typedef struct s_msgbuf
{
        long mtype;
        char mtext[512];
}t_msgbuf;


int main(int argc,char **argv)
{
        key_t           key;
        int                     msgid;
        t_msgbuf        msgbuf;
        int                     msgtype;
        int                     i;


        if( (key = ftok(FTOK_PATH,FTOK_PROJID)) < 0 )
        {
                printf("ftok() get IPC token failure : %s\n",strerror(errno));
                return -1;
        }


        msgid = msgget(key,IPC_CREAT|0666);

        if(msgid < 0 )
        {
                printf("shmget() create shared memory failure : %s\n",strerror(errno));
                return -2;
        }


        msgtype = (int)key;
        printf("key[%d] msgid[%d] msgypte[%d]\n",(int)key,msgid,msgtype);

        for(i=0;i<4;i++)
        {
                msgbuf.mtype = msgtype;
                strcpy(msgbuf.mtext,"Ping");

                if(msgsnd(msgid,&msgbuf,sizeof(msgbuf.mtext),IPC_NOWAIT) < 0 )
                {
                        printf("msgnd() send message failure : %s\n",strerror(errno));
                        break;
                }
                printf("Send message : %s\n",msgbuf.mtext);
                sleep(1);

        }

        msgctl(msgid,IPC_RMID,NULL);
        return 0;
}
 

 

 

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

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>

#define FTOK_PATH               "/dev/zero"
#define FTOK_PROJID             0x22

typedef struct s_msgbuf
{
        long    mtype;
        char    mtext[512];
}t_msgbuf;


int main(int argc,char **argv)
{
        key_t           key;
        int                     msgid;
        t_msgbuf        msgbuf;
        int                     msgtype;
        int                     i;

        if( (key = ftok(FTOK_PATH,FTOK_PROJID)) < 0 )
        {
                printf("ftok() get IPC token failure : %s\n",strerror(errno));
                return -1;
        }

        msgid = msgget(key,IPC_CREAT|0666);

        if( msgid < 0 )
        {
                printf("shmget() create shared memory failure : %s\n",strerror(errno));
                return -2;
        }

        msgtype = (int)key;
        printf("key[%d], msgid[%d] msgypte[%d]\n",(int)key,msgid,msgtype);

        for(i=0;i<4;i++)
        {
                memset(&msgbuf,0,sizeof(msgbuf));

                if( msgrcv(msgid,&msgbuf,sizeof(msgbuf.mtext),msgtype,IPC_NOWAIT) < 0 )
                {
                        printf("msgsnd() receive message failure : %s\n",strerror(errno));
                        break;
                }

                printf("Receive message : %s\n",msgbuf.mtext);
                sleep(1);
        }

        msgctl(msgid,IPC_RMID,NULL);
        return 0;
}
 

 

 

小李要努力写代码
关注
  • 22
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
linux——进程间通信IPC
a_zxswer的博客
12-18 423
Linux中七种IPC详解，进程间通信
Linux——进程间通信
weixin_46107667的博客
05-04 237
进程间通信进程间通信进程间通信的本质进程间通信的目如何可以做到进程间通信进程间通信分类管道什么是管道?匿名管道管道的特点管道的四种情况命名管道匿名管道和命名管道的区别System V共享内存共享内存建立的过程共享内存函数共享内存特点消息队列信号量POSIX 进程间通信 进程间通信的本质 进程间通信的本质就是不同的进程可以看见同一份资源 进程间通信的目 数据传输：一个进程需要将它的数据发送给另外一个进程 资源共享：多个进程之间共享相同的资源 通知事件：一个进程需要向另外一个或者一组进程发送消息，通知发生
Linux学习笔记——进程间通信
weixin_55051736的博客
04-09 620
单进程无法使用并发的能力，更无法实现多进程协同工作，所以进程间通信时一种手段，目的是要实现多进程协同。
Linux —— 进程间通信
M的博客
07-23 5786
进程间通信方式的介绍：管道通信、system V通信......
Linux学习——进程间通信（IPC）（一）
m0_70569293的博客
03-17 1837
回顾之前提到的话题，fork()函数被调用一次，都有两个返回值。两次返回值的区别是子进程的返回值是0，父进程的返回值是子进程的进程id。之所以将子进程的进程id返回给父进程是因为：一个进程的子进程可以多于一个，没有一个函数使一个进程可以获得其所有子进程的进程id；对于子进程来说，之所以fork()返回0给他，是因为他可以随时调用getpid()来获取自己的进程号，也可以通过getppid()来获得父进程的进程号。
Linux操作系统实验 —— 进程间通信
m0_74738450的博客
01-24 1471
本次实验主要围绕Linux环境下的进程间通信（IPC）展开，涉及了不同的通信方法和进程同步的概念。总体而言，进程之间的通信主要有两种方式，分别是消息队列和共享内存，除此之外，我们还学习了如何使用多线程和信号量的方法解决生产者-消费者的问题，增强了对于进程通信和进程同步的理解和掌握。1.消息队列：- 消息队列是一种进程间通信的方式，通过在进程间传递消息实现数据交换。- 在实验中，我们通过使用msgget、msgsnd和msgrcv等系统调用来创建消息队列、向队列发送消息和从队列接收消息。
操作系统6————进程间通信IPC
冰炭不投day的博客
02-02 1433
操作系统6————进程间通信IPC 一.目录 操作系统6————进程间通信IPC 一.目录 二.进程通信概述 三.共享存储器 1. 概述 2. 共享某些数据结构 3. 共享存储区 四.管道通信 1.概述 2. 管道机制必须提供的协调能力 3. Linux中的无名管道 4. Linux中的命名管道(FIFO) 五.消息传递机制 1. 概述 2.直接消息传递系统的实现方式 3.信...
Linux——进程间通信（消息队列）
m0_49830036的博客
09-17 424
系统建立IPC通讯 （消息队列、信号量和共享内存） 时必须指定一个ID值。简单的demo：server端可以发送消息给client端，client端可以实时获取打印到终端显示。3.消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。1.消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。字符的输入与输出使用gets()和puts()的原因：scanf输入。
linux学习——进程间通信之管道
左手倒影，右手年华
10-28 324
在linux系统中，进程间通信主要有以下几种方式，这一期及以后的博文中将对各种进程间通信进行介绍。 1、管道 2、命名管道 3、信号 4、信号量 5、消息队列 6、共享内存 7、套接字 在本文中，将对管道进行说明。一、管道 管道是UNIX IPC的最老形式，并且所有U N I X系统都提供此种通信机制，管道有两种限制： (1) 它们是半双工的。数据只能在一
Linux进程间通信（五）——进程间通信
天山老妖
02-27 235
一、进程间通信简介 Linux的进程通信方式基本上是从Unix平台上的进程通信方式继承而来的。在Unix发展过程中，贝尔实验室和BSD（加州大学伯克利分校的伯克利软件发布中心）是Unix发展的主要贡献者，但两者在进程间通信方面的侧重点有所不同。贝尔实验室对Unix早期的进程间通信方式进行了系统的改进和扩充，形成了 “system V IPC”，通信进程局限在本地计算机内；BSD则跳过了进程通信局限在本地计算机的限制，形成了可以在计算机间进行通信的基于套接口（socket）的进程间通信机制。Linux则继承
Linux通过匿名管道进行进程间通信
09-15
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是实现不同进程间数据共享和协调工作的重要手段。本文将深入探讨一种常见的IPC方式——匿名管道，以及如何使用`popen`函数进行管道通信。 **一...
LINUX进程间通信的模型检测.pdf
09-06
本文《LINUX进程间通信的模型检测》深入探讨了如何利用模型检测技术来验证Linux IPC机制的正确性和可靠性。 模型检测是一种用于自动分析和验证有限状态系统的强大技术。它通过构建系统的模型，并使用特定的工具，如...
高级进程间通信问题——快速排序问题1
08-03
【高级进程间通信问题——快速排序问题1】的实验是一个基于操作系统原理的编程挑战，旨在实现一个多线程或多进程的快速排序算法。这个实验在Ubuntu 18.04.5 LTS环境下进行，采用C/C++编程语言，并且允许使用C++11的...
Linux系统编程实验六进程间通信.docx
11-01
在本实验中，我们主要探讨了Linux系统编程中的两个核心概念：进程间通信（IPC，Inter-Process Communication）以及信号处理。实验环境是基于Linux的虚拟机，通过编写C语言程序来实现这些功能。 首先，我们关注的是...
Linux进程间通信-信号通信实例.pdf
07-11
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是多个进程间进行数据交换的重要手段。本文将深入探讨一种常见的IPC方式——信号（Signal）通信，通过几个实例来阐述其基本概念和使用方法。 ...
【Linux】Xshell和Xftp简介_安装_VMware虚拟机使用
wosixiaokeai的博客
06-19 1254
Xftp是一个功能强大的SFTP、FTP文件传输软件，它允许MS Windows用户安全地在UNIX/Linux和Windows PC之间传输文件。Xftp支持SFTP协议，确保所有通过该软件的网络流量都是加密的。它采用了标准的Windows风格的向导，用户界面直观易用，可以很好地与其他Windows应用程序协同工作。Xftp的特色功能包括同步功能、直接编辑远程文件、多窗格支持、文件交换协议（FXP）支持等，这些功能使得文件传输更加容易和快捷。
Linux中文件查找相关命令比较
lurenyi168的专栏
06-16 466
Linux中与文件定位的命令有find、locate、whereis、which，type。
Linux开发讲课7---Linux sysfs文件系统
最新发布
qq_42837317的博客
06-21 828
Sysfs通过文件和目录的方式组织信息，其中每个文件或目录对应于系统中的一个设备、驱动程序或者其他内核对象。当内核中的设备、驱动程序等对象被创建时，相应的Kobject也会被创建，然后通过Sysfs将其信息暴露给用户空间。Sysfs通常被挂载在/sys目录下，它提供了一种方便的方式，让用户空间的程序可以动态地获取和管理系统中的设备信息，而无需直接访问内核数据结构。（2）创建sysfs文件。其中attr表示将要创建的文件（属性），而show和store分别表示对应的sysfs文件在读和写操作时的回调函数。
SUSE linux的快照和恢复
大龄IT民工
06-19 1172
openSUSE默认提供了通用场景下的快照设置，你也可以根据需要进行修改。
Linux进程间通信(IPC)
08-21
Linux提供了多种进程间通信（IPC）的方式，以下是几种常见的IPC方法： 1. 管道（Pipe）：管道是一种半双工的通信方式，可以在父进程和子进程之间传递数据。它有两种类型：匿名管道和命名管道。 2. 共享内存...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值