第二篇：进程间通信

已于 2022-08-30 22:43:15 修改
阅读量941 收藏
点赞数
文章标签： 单片机 stm32 vim c语言
于 2022-08-30 22:40:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52046032/article/details/126596712
版权

        目录

一、共享内存

（1）创建、打开共享内存

（2）内存映射 -- shmat

（3）取消内存映射

（4）删除共享内存

二、消息队列

      1.创建、打开消息队列       -----msgget

     2.发送消息                        -------msgsnd

3.接收消息队列                --------msggrcv

 4、删除消息队列                ------msgctl

例子：

三、信号灯集

        1.创建、打开信号灯集---semget

        2.初始化信号灯集---semctl

        3.p/v操作 --- semop

        4.删除信号灯集 ---semctl

例子：

        前面一篇讲述了进程间通信的两种方式（管道、信号），管道又分为有名管道换句话说就是在进程工作环境下可以看见一个创建的管道文件，而无名管道看不见这个管道文件。使用信号的方式有几种方式，一种是使用shell指令发送指定信号，如果没有使用更改执行状态一般默认操作。进程中可以使用kill函数给出指定的进程发送信号完成相关的动作，除了使用kill函数还可以使用raise函数给本进程发送信号，定时器发送信号等等

一、共享内存

（1）创建、打开共享内存

#include <sys/ipc.h>
#include <sys/shm.h>

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


参数：
    key：ftok得到的key值或者IPC_PRIVATE（创建私有的共享内存）
    size:共享内存大小
    shmflg：一般填IPC_CREAT | 0664

返回值：
    成功返回共享内存ID，失败返回-1

（2）内存映射 -- shmat

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

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

参数：
    shmid：共享内存的ID
     void *shmaddr：表示用户指定的映射地址，如果填NULL，表示该映射地址由系统自动分配
    shmflg：SHD_RDONLY --- 只读
            0   --可读可写

返回值：成功返回映射地址，失败返回-1

（3）取消内存映射

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

int shmdt(const void *shmaddr);

参数：
    shmaddr：映射地址

返回值：
    成功返回0，失败返回-1

（4）删除共享内存

#include <sys/ipc.h>
#include <sys/shm.h>

int shmctl(int shmid,int cmd,struct shmid_ds*buf);

参数：
    shmid：共享内存id
    cmd：
        IPC_STAT:获取共享内存信息
        IPC_SET：设置共享内存
        IPC_RMID:删除共享内存，第三个填NULL


返回值：
    失败返回-1

例子：利用共享内存，一个进程向共享内存写入数据，另一个进程打印输出

/******************************
****************读取信息*******/
#include <stdio.h>
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char *argv[])
{ 
	key_t key = ftok(".", 'q');
	if(key < 0)
	{
		perror("ftok");
		exit(-1);
	}	
	
    //1、创建、打开共享内存
    int shmid = shmget(key, 512, IPC_CREAT|0664);
    if(shmid < 0)
    {
    	perror("shmget");
    	exit(-1);
    }
   
    //2、内存映射
    void *addr = shmat(shmid, NULL, 0);
    if(addr == (void *)-1)
    {
    	perror("shmat");
    	exit(-1);
    }

    //3、从共享内存中读取数据打印输出
    while(1)
    {
    	printf("%s", (char *)addr);
    }

    //4、取消映射
    int ret = shmdt(addr);
    if(ret < 0)
    {
    	perror("shmdt");
    	exit(-1);
    }
    
    //5、删除共享内存
    ret = shmctl(shmid, IPC_RMID, NULL);
    if(ret < 0)
    {
    	perror("shmctl");
    	exit(-1);
    }
    return 0;
} 
//发送信息
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char *argv[])
{ 
 	key_t key = ftok(".", 'q');
	if(key < 0)
	{
		perror("ftok");
		exit(-1);
	}	
	
    //1、创建、打开共享内存
    int shmid = shmget(key, 512, IPC_CREAT | 0664);
    if(shmid < 0)
    {
    	perror("shmget");
    	exit(-1);
    }
   
    //2、内存映射
    void *addr = shmat(shmid, NULL, 0);
    if(addr == (void *)-1)
    {
    	perror("shmat");
    	exit(-1);
    }

    //3、向共享内存中写入数据
    
    while(1)
    {
    	fgets((char *)addr, 512, stdin);
    }

    //4、取消映射
    int ret = shmdt(addr);
    if(ret < 0)
    {
    	perror("shmdt");
    	exit(-1);
    }
    

    
    return 0;
}

二、消息队列

        消息队列可以根据消息类型，选择性的接收和发送

        消息队列的操作流程

      1.创建、打开消息队列       -----msgget

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

   int msgget(key_t key, int msgflg);	
   参数：
   	key：ftok得到的key值，或者填IPC_PRIVATE
   	msgflg：IPC_CREAT|0664
   	
   返回值：
   	成功返回消息队列id，失败返回-1；

     2.发送消息                        -------msgsnd

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

   int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
	参数：
		msqid：消息队列id
		msgp:消息结构体的地址
		msgsz：消息正文的大小
		msgflg: 
				0 -- 以阻塞方式发送
				IPC_NOWAIT -- 以非阻塞方式发送

	返回值：
		成功返回0，失败返回-1；

   封装消息结构体：

​			typedef struct msgbuf

​			{

​						long mtype;

​						char mtext[64]；

​			}MSG；	

​			#define SIZE (sizeof(MSG)-sizeof(long))

​			MSG mbuf;

​			mbuf.mtype = 100;

​			fgets(buf, 64, stdin);

​			strcpy(mbuf.mtext, buf);

​			msgsnd(msgid， &mbuf, SIZE, );

3.接收消息队列                --------msggrcv

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

 4、删除消息队列                ------msgctl

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

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

例子：

        这里是利用消息队列创建一个接收和发送消息：

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
typedef struct msgbuf   //定义消息结构体
{
    long mtype;
    char mtext[64];
}MSG;

#define typeA 100
#define typeB 200
#define SIZE (sizeof(MSG)-sizeof(long))

int main(int argc, char *argv[])
{
    MSG m_buf;

    key_t key = ftok("/", 'a');   //获取key值
    if(key < 0)
    {
        perror("ftok");
        exit(-1);
    }

    int msgid = msgget(key, IPC_CREAT|0664);  //创建或者打开消息队列
    if(msgid < 0)
    {
        perror("msgget");
        exit(-1);
    }

    int ret = 0;
    char buf[64] = {0};

    while(1)
    {
        m_buf.mtype = typeA;   //填充消息结构体的类型
        printf("input>>:");
        fgets(buf, 64, stdin);
        strcpy(m_buf.mtext, buf);    //填充消息结构体的正文

        ret = msgsnd(msgid, &m_buf, SIZE, 0);  //发送消息
        if(ret < 0)
        {
            perror("msgsnd");
            exit(-1);
        }
        if(strcmp(buf, "quit\n") == 0)
        {
            printf("bye~\n");
            break;
        }

        memset(&m_buf, 0, sizeof(MSG));   //清空消息结构体
        ret = msgrcv(msgid, &m_buf, SIZE, typeB, 0);   //接受消息类型为typeB的消息
        if(ret < 0)
        {
            perror("msgrcv");
            exit(-1);
        }
        if(strcmp(m_buf.mtext, "quit\n") == 0)
        {
            printf("bye~\n");
            msgctl(msgid, IPC_RMID, NULL);
            break;
        }
        printf("%s\n", m_buf.mtext);   //打印接收内容

    }



    return 0;
}

三、信号灯集

        1.创建、打开信号灯集---semget

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

       int semget(key_t key, int nsems, int semflg);
参数：
    key :和信号灯集关联的key值
    nsems:信号灯集中包含的信号灯数目
    semflg:信号灯集的访问权限，通常为IPC_CREAT | 0666
返回值：
    
    成功：信号灯集ID
    失败：-1

        2.初始化信号灯集---semctl

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

   int semctl(int semid, int semnum, int cmd, ...);		
   参数：
   	semid：信号灯集ID
   	semnum：操作信号灯的编号，下标从0开始
   	cmd：操作信号灯的指令
   		SETVAL：设置信号灯的初值
   		例：
   			union semun
   			{
   				int val;
   			};
   			union semun my_un;
   			my_un.val = 1;   			
   			semctl(semid, 0, SETVAL, my_un);

        3.p/v操作 --- semop

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

       int semop(int semid, struct sembuf *sops, size_t nsops);
   
参数：
    semid：信号灯集id
            struct sembuf{
               unsigned short sem_num;  /* 要操作的信号灯编号 */
               short          sem_op;   /*  
                                        //0:等待，知道信号灯的值变成0
                                        //1:释放资源，V操作
                                        //-1:分配资源，P操作
                                        */
               short          sem_flg;  /* 操作标志：0，IPC_NOWAIT,SEM_UNDO */
            };
    nsops:要操作的信号灯个数
返回值：成功为0
        失败为-1

        4.删除信号灯集 ---semctl

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

   int semctl(int semid, int semnum, int cmd, ...);
参数：
semid:信号灯集D
semnum:要修改的信号灯编号
cmd: GETVAL:获取信号灯的值
SETVAL:设置信号灯的值
IPC_RMID:从系统中删除信号灯集合

semctl(semid, 0, IPC_RMID);

例子：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <signal.h>

union semun {
	int val;    
};


void sem_init(int semid, int num[], int n)
{ 
	union semun mymun;
	int i = 0;
	for(i = 0; i < n; i++)     //循环给信号灯集中的信号依次赋初始值
	{
		mymun.val = num[i];
		semctl(semid, i, SETVAL, mymun);
	}
}

void pv(int semid, int num, int op)
{
	struct sembuf buf;
	buf.sem_num = num;
	buf.sem_op = op;
	buf.sem_flg = 0;
	semop(semid, &buf, 1);
}


int main(int argc, char *argv[])
{
	int shmid, semid;
	int num[2] = {0,1};
	//key_t key;
	pid_t pid;
	char *shmaddr;
/*
	if((key = ftok(".", 't')) < 0)
	{
		perror("ftok");
		exit(-1);
	}
*/

	if((shmid = shmget(IPC_PRIVATE, 512, 0666 )) < 0)   //创建私有的共享内存
	{
		perror("shmget");
		exit(-1);
	}

	if((shmaddr = (char *)shmat(shmid, NULL, 0)) == (char *)-1)   //共享内存映射
	{
		perror("shmat");
		goto _error1;
	}
	
	if((semid = semget(IPC_PRIVATE, 2, 0666)) < 0)     //创建私有的信号灯集
	{
		perror("semget");
		goto _error1;
	}

	sem_init(semid, num, 2);      //信号灯集的初始化

	if((pid = fork()) < 0)        //创建子进程
	{
		perror("fork");
		goto _error2;
	}
	else if(pid == 0)            //操作子进程
	{
		char *p, *q;
		while(1)
		{
			pv(semid, 0, -1);     //对第一个信号灯做P操做 此时第一个信号灯的值为0  所以阻塞在这一步，如果该信号灯的值为1 则会执行后面的程序
			p = shmaddr;
			q = shmaddr;
			while(*p != '\0')    //处理共享内存中字符串中的空格
			{
				if(*p != ' ')
				{
					*q++ = *p;
				}
				p++;
			}
			*q = '\0';
			printf("%s", shmaddr);    //打印共享内存中的内容
			pv(semid, 1, 1);     //对第二个信号灯做V操作， 让第二个信号灯的值+1
		}

	}
	else         					//操作父进程
	{
		while(1)
		{
			pv(semid, 1, -1);       //对第二个信号灯做P操作   此时第二个信号灯的初始值为1，执行之后第二个信号灯的值-1
			printf("input > ");
			fgets(shmaddr, 64, stdin);            //向共享内存中写入数据
			if(strcmp(shmaddr, "quit\n") == 0)     
			{
				break;
			}                           
			pv(semid, 0, 1);         //对第一个信号灯做V操作，此时第一个信号灯的初始值为0，此操作之后值+1
		}
		kill(pid, SIGUSR1);       //向子进程发送SIGUSR1 这个信号的默认处理方式是结束该进程
	}

_error2:
	semctl(semid, 0, IPC_RMID);

_error1:
	shmctl(shmid, IPC_RMID, NULL);

	return 0;
}

刂LU
关注
linux进程间通信-信号量（semaphore）
m0_74282605的博客
09-14 185
举个例子，就是 两个进程共享信号量sv，一旦其中一个进程执行了P(sv)操作，它将得到信号量，并可以进入临界区，使sv减1。而第二个进程将被阻止进入临界区，因为 当它试图执行P(sv)时，sv为0，它会被挂起以等待第一个进程离开临界区域并执行V(sv)释放信号量，这时第二个进程就可以恢复执行。一个不完备的解决方案是：在调用semget时指定IPC_CREAT | IPC_EXCL标志，这样只有一个进程（首先调用semget的那个进程）创建所需信号量，该进程随后初始化该信号量。
进程间的通信（一）
susershine的专栏
11-20 970
进程间有很多的通信方式，包括：管道（pipe），命名管道（named pipe），信号（signal），消息（message）队列，共享内存，内存映射（mapped memory），信号量以及套接口（socket）。下面就逐一的介绍着几种通信方式。 一、 管道 管道是一种半双工的通信方式，用于具有亲缘关系的进程进行单方向的通信。linux用pipe函数创建一个管道，其函数原型为： #incl
Linux IPC 进程间通信——信号量sem
ctgulvzhaole的博客
01-28 2140
Linux 进程间通信——信号量sem
【进程间通信】------信号量（sems）
daboluo521的博客
04-22 814
一直想看看ftok函数，今天就在这里进行简单的介绍下 ftok（）函数我们在进行IPC通讯的时候必须指定一个ID值，这个值通常情况下就是由ftok进行提供。 ftok原型如下： key_t ftok( char * fname, int id ) 参数说明： fname就时您指定的文档名 id是子序号...
Linux信号的使用和进程间通信
qq_41721746的博客
10-23 706
一、信号的使用 1. 信号的基本概念 2. 修改信号的响应方式---signal() 3. 发送信号---kill() 二、 进程间通信（IPC） 1. 管道 2. 信号量 3. 共享内存 4. 消息队列
DPDK : 进程间通信以及在内存管理的应用
pcokk的博客
05-12 3234
说明        这一篇文章主要是对DPDK中的进程间通信(Inter-Process Communication)进行介绍。        由于个人水平所限，若所写的博文中存在错误，希望大家能帮忙指出。 一，DPDK的进程间通信   &...
Linux操作系统实验：进程间通信与管道、消息队列
这篇实验报告主要探讨了在Linux操作系统中如何实现进程间通信，包括使用`fork()`函数创建进程、通过管道(Pipe)实现简单通信以及利用消息队列进行更复杂的通信方式。实验旨在帮助学生熟悉Linux环境下的程序开发，掌握...
Linux：进程间通信之管道
ETalien_的博客
01-14 290
进程间通信----管道篇 一、进程间通信 进程间通信本质上就是让不同的进程看到一份共同的资源。 进程间通信的目的： 数据传输：⼀个进程需要将它的数据发送给另⼀个进程 资源共享：多个进程之间共享同样的资源。 通知事件：⼀个进程需要向另⼀个或⼀组进程发送消息，通知它（它们）发⽣了某种事件（如进程终⽌时要通知⽗进程）。 进程控制：有些进程希望完全控制另⼀个进程的执⾏（如Debug进程），此时控制进程希...
信号量
03-31 1493
信号量的数据类型为结构sem_t，它本质上是一个长整型的数。函数sem_init（）用来初始化一个信号量。它的原型为：　　<br />extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));　　<br />sem为指向信号量结构的一个指针；pshared不为０时此信号量在进程间共享，否则只能为当前进程的所有线程共享；value给出了信号量的初始值。　　<br />函数sem_post( sem_t *sem
linux 多线程之信号量 sem_init
热门推荐
岁月斑驳7的博客
09-29 4万+
1. 什么是信号量 linux sem 信号量是一种特殊的变量，访问具有原子性， 用于解决进程或线程间共享资源引发的同步问题。 用户态进程对 sem 信号量可以有以下两种操作： -&amp;gt; 等待信号量 当信号量值为 0 时，程序等待；当信号量值大于 0 时，信号量减 1，程序继续运行。 -&amp;gt; 发送信号量 将信号量值加 1 通过对信号量的控制，从而实现共享资源的顺序访问。 2. 相关函...
Linux信号量sem_init,sem_wait,sem_post
最新发布
weixin_42936764的博客
11-28 2270
线程的信号量与进程间通信中使用的信号量的概念是一样，它是一种特殊的变量，它可以被增加或减少，但对其的关键访问被保证是原子操作。pshared控制信号量的类型，如果其值为0，就表示这个信号量是当前进程的局部信号量，否则信号量就可以在多个进程之间共享，value为sem的初始值。该函数用于以原子操作的方式将信号量的值减1。信号量的函数都以sem_开头，线程中使用的基本信号量函数有4个，它们都声明在头文件semaphore.h中。该函数初始化由sem指向的信号对象，设置它的共享选项，并给它一个初始的整数值。
linux_信号量函数系列-信号量实现生产者消费者模型-sem_init函数-sem_wait函数-sem_post函数-sem_trywait函数
qq_44177918的博客
05-04 4294
sem_init函数-sem_wait函数-sem_post函数-sem_trywait函数 定义两个信号量：S满 = 0， S空 = 1 （S满代表满格的信号量，S空表示空格的信号量，程序起始，格子一定为空）。sem_post： 将信号量++，同时唤醒阻塞在信号量上的线程 （类比pthread_mutex_unlock）;但，由于sem_t的实现对用户隐藏，所以所谓的++、–操作只能通过函数来实现，而不能直接++、–符号。sem_wait: 1. 信号量大于0，则信号量-- （类比pthread_mut
信号量sem_init,sem_wait,sem_post
我的梦
10-23 2万+
本篇文章是信号量的简单入门，主要学习关于信号量四个函数的使用。
进程间通信
m0_64259792的博客
07-25 612
如果我们不创建一个新的信号量集，而是访问一个已经存在的信号量集，此处参数应该。ifcmd==GETALL,arg应该为一个short数组的首地址，用来保存所有信号量的值。ifcmd==SETALL,arg应该为一个short数组的首地址，用来保存所有信号量的值。//无论是P操作还是V操作，实质就是对信号量的值进行操作。ifcmd==SETVAL,arg应该为一个short的整数，用来指定该信号量的值。ifcmd==GETVAL,arg则不需要，semctl的返回值就是该信号量的值。...
学习信号量 sem_init、sem_destroy、sem_post、sem_wait、sem_trywait、sem_getvalue
hanshanbuleng的博客
04-30 8873
学习信号量 sem_init、sem_destroy、sem_post、sem_wait、sem_trywait、sem_getvalue 概要： 1.信号量使用场合 2.POSIX标准定义的信号量 2.1 sem_init、sem_destroy、sem_post、sem_wait、sem_trywait、sem_getvalue简介 3.在linux中相关函数位置 1.信号量使用场合 我理解...
内存信号量sem_init函数解析
风之伤
03-12 3660
int sem_init(sem_t *sem, int pshared, unsigned int value); return 0 on success,or -1 on error 本文着重解析sem_init第二个参数 pshared ，下面摘自《The Linux Programming Interface》 这一段大体意思：如果pshared是0 则可以在线程
20230803 linux信号量sem sem_init(sem_t* m_sem,0,0)
HITORANGE的博客
08-03 313
信号量及一切定义为指针类型的变量使用前一定要先new 一个实例化对象将地址给该指针，否则指针没有确定的地址，运行后直接访问该错误地址报段错误。sem_post ， sem_wait 用法与线程同步信号量相同。跟随主进程通过信号量同步的进程初始化。多进程共用信号量使用有名信号量。
sem_init函数
zjhkobe的专栏
09-23 2752
#include 　　int sem_init(sem_t *sem, int pshared, unsigned int value);   　　sem_init() 初始化一个定位在 sem 的匿名信号量。value 参数指定信号量的初始值。 pshared 参数指明信号量是由进程内线程共享，还是由进程之间共享。如果 pshared 的值为 0，那么信号量将被进程内的线程共享，
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值