第二篇：进程间通信

已于 2022-08-30 22:43:15 修改
阅读量620 收藏
点赞数
文章标签： 单片机 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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
利用信号量实现进程间同步
10-21
压缩包内含4个文件：a.c，b.c是两个源文件，分别用来模拟读端和写端。semaphore.h和semaphore.c主要实现了sem_init，sem_p，sem_v，sem_del这四个函数（函数体内是转调semget，semctl，semop，这三个函数都是linux提供的库函数）。以一个.txt文件来模拟临界资源。
Linux信号量sem_init,sem_wait,sem_post
weixin_42936764的博客
11-28 1554
线程的信号量与进程间通信中使用的信号量的概念是一样，它是一种特殊的变量，它可以被增加或减少，但对其的关键访问被保证是原子操作。pshared控制信号量的类型，如果其值为0，就表示这个信号量是当前进程的局部信号量，否则信号量就可以在多个进程之间共享，value为sem的初始值。该函数用于以原子操作的方式将信号量的值减1。信号量的函数都以sem_开头，线程中使用的基本信号量函数有4个，它们都声明在头文件semaphore.h中。该函数初始化由sem指向的信号对象，设置它的共享选项，并给它一个初始的整数值。
linux semget的参数理解system V
最新发布
weixin_39291964的博客
03-05 377
semget函数是UNIX和Linux系统中用于创建新的信号量集或获取已存在的信号量集的系统调用。它的作用是在进程间同步或共享资源时使用。理解semget的参数对于正确使用信号量机制非常重要。下面是对semget。
信号量
03-31 1418
信号量的数据类型为结构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函数-sem_wait函数-sem_post函数-sem_trywait函数
qq_44177918的博客
05-04 2987
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
linux 多线程之信号量 sem_init
热门推荐
岁月斑驳7的博客
09-29 3万+
1. 什么是信号量 linux sem 信号量是一种特殊的变量，访问具有原子性， 用于解决进程或线程间共享资源引发的同步问题。 用户态进程对 sem 信号量可以有以下两种操作： -&amp;gt; 等待信号量 当信号量值为 0 时，程序等待；当信号量值大于 0 时，信号量减 1，程序继续运行。 -&amp;gt; 发送信号量 将信号量值加 1 通过对信号量的控制，从而实现共享资源的顺序访问。 2. 相关函...
信号量sem_init,sem_wait,sem_post
我的梦
10-23 2万+
本篇文章是信号量的简单入门，主要学习关于信号量四个函数的使用。
信号量详细解说
modi000的博客
05-18 1221
1、信号量概述 进化版的互斥锁（1 --> N） 由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。线程从并行执行，变成了串行执行。与直接使用单进程无异。 信号量，是相对折中的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。 2、主要应用函数： sem_init() 函数 功能：初始化一个信号...
进程间通信
m0_64259792的博客
07-25 581
如果我们不创建一个新的信号量集，而是访问一个已经存在的信号量集，此处参数应该。ifcmd==GETALL,arg应该为一个short数组的首地址，用来保存所有信号量的值。ifcmd==SETALL,arg应该为一个short数组的首地址，用来保存所有信号量的值。//无论是P操作还是V操作，实质就是对信号量的值进行操作。ifcmd==SETVAL,arg应该为一个short的整数，用来指定该信号量的值。ifcmd==GETVAL,arg则不需要，semctl的返回值就是该信号量的值。...
微服务实战（三）：深入微服务架构的进程间通信
02-26
【编者的话】这是采用微服务架构创建自己应用...因此，如下图所示，服务之间的交互必须通过进程间通信（IPC）来实现。后面我们将会详细介绍IPC技术，现在我们先来看下设计相关的问题。当为某一个服务选择IPC时，首先
微服务：从设计到部署(二)
02-25
本文是系列文章，文章的第一篇本书是关于如何使用微服务架构构建应用程序，这是本书的第三章。...因此，如图3-1所示，服务必须使用进程间通信（IPC）机制进行交互。稍后我们将了解到多种IPC技术，但在此之
Visual C++实践与提高——串口通信与工程应用篇1
02-11
第2章 使用MSComm控件编程 21 2.1 MSComm控件属性及事件 21 2.1.1 MSComm最常用的属性 21 2.1.2 与输入操作有关的属性 23 2.1.3 与输出操作有关的属性 24 2.1.4 与传输控制有关的属性 25 2.1.5 MSComm控件的事件 26 ...
学习信号量 sem_init、sem_destroy、sem_post、sem_wait、sem_trywait、sem_getvalue
hanshanbuleng的博客
04-30 7629
学习信号量 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 3486
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 246
信号量及一切定义为指针类型的变量使用前一定要先new 一个实例化对象将地址给该指针，否则指针没有确定的地址，运行后直接访问该错误地址报段错误。sem_post ， sem_wait 用法与线程同步信号量相同。跟随主进程通过信号量同步的进程初始化。多进程共用信号量使用有名信号量。
进程间的通信（一）
susershine的专栏
11-20 932
进程间有很多的通信方式，包括：管道（pipe），命名管道（named pipe），信号（signal），消息（message）队列，共享内存，内存映射（mapped memory），信号量以及套接口（socket）。下面就逐一的介绍着几种通信方式。 一、 管道 管道是一种半双工的通信方式，用于具有亲缘关系的进程进行单方向的通信。linux用pipe函数创建一个管道，其函数原型为： #incl
linux sem 多进程sem_open sem_init,信号灯-布布扣-bubuko.com
weixin_29623163的博客
05-25 2426
概念：信号灯用来实现同步——用于多线程，多进程之间同步共享资源(临界资源)。信号灯分两种，一种是有名信号灯，一种是基于内存的信号灯。有名信号灯，是根据外部名字标识，通常指代文件系统中的某个文件。基于内存的信号灯，它主要是把信号灯放入内存的，基于内存的信号灯，同步多线程时，可以放到该多线程所属进程空间里；如果是同步多进程，那就需要把信号灯放入到共享内存中(方便多个进程访问)。有名信号灯和基于内存的信...
Linux sem_init()
weifc-wei 的博客
10-19 1381
#include <semaphore.h> int sem_init(sem_t *sem, int pshared, unsigned int value); 描述: int sem_init(sem_t *aaa, int bbb, unsigned int ccc); sem_init()在aaa指向的地址初始化未命名的信号量，ccc参数指定信号量的初始值。 bbb参数指示这个信号量是在进程的线程之间共享，还是在进程之间共享。 如果bbb的值为0，那么这个信号量在进程的线程之间共
unix网络编程 卷2:进程间通信 pdf
06-24
Unix网络编程卷2：进程间通信PDF是一本非常有用的书籍，它涵盖了关于进程间通信的所有关键知识。 进程间通信是指进程之间交换数据或信息的过程，这对于理解操作系统以及网络编程非常重要。本书不仅讲解了进程通信的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值