Linux-C 进程通信之system-V IPC

Linux-C 进程通信之system-V IPC

一、简述

       记--简单的system-V IPC 例子。其中包括消息队列、共享内存、信号量。

        多进程间使用IPC对象进行通信。有一个key值唯一标识这个IPC对象，进程间通过这个大家都知道的一样的key来进行获取对应的IPC对象，从而进行通信，这个key可以人为直接指定，但需要确保唯一性，不能与已存在的不一样作用的重复，为此可以使用ftok()函数按照相关条件生成，只有双方条件一致key才相同，这样key一样的也就正好对应需要通信的双方。

        使用命令：ipcs -a 来查看所有IPC对象

       或者使用:ipcs -q     查看消息队列，ipcs -s   查看信号量   ，  ipcs -m 查看共享内存

      删除指定的消息队列：ipcrm -q MSG_ID 或者 ipcrm -Q msg_key 

      删除指定的共享内存：ipcrm -m SHM_ID 或者 ipcrm -M shm_key 

      删除指定的信号量：ipcrm -s SEM_ID 或者 ipcrm -S sem_key

二、消息队列

       消息队列提供一种带有数据标识的特殊管道，对于多进程间的通信，可以根据数据标识来区分多个进程。

      例如b进程标识数据类型为11，那么可以根据类型11在消息队列中获取b进程的数据。多个进程可以操作同一个消息队列，可以从消息队列中读取数据，也可以往消息队列写入数据。一个进程可以发送多种类型的消息。其实可以将消息队列简单的看做带数据格式的管道。里面的数据格式是自定义的。

     主要操作函数：

          int msgget(key_t key, int msgflg);//获取或创建共享对象的ID号
    
          int msgctl(int msqid, int cmd, struct msqid_ds *buf);//控制指定ID的IPC对象

          int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);//往指定的IPC对象(消息队列)写入信息

     ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);//从指定的IPC对象(消息队列)获取消息。

      2.1 ftok()函数

 2.2 msgget()函数

 3.3 msgsnd()函数

  3.4 msgctl()函数

例子：总共三个进程，进程receive负责监听并读取消息队列的内容，并打印对应打印消息类型，进程send_a,send_b负责添加消息到队列中，其中进程send_a的消息类型为10,进程send_b的消息类型为11。例子中用的是不断轮询方式监听消息队列(就是轮流地读取消息队列)，也可以使用线程方式对某种消息类型进行单独监听。

        测试代码

        receive.c文件

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

#define MSG_TYPE	0
#define MSG_TYPE_A	10
#define MSG_TYPE_B	11

//自定义，方便按照消息类型进行处理
struct msgbuf 
{
    long mtype;       /* message type, must be > 0 */
    char mtext[100];    /* message data */
	int pid;
};


int main(void)
{
	key_t key;

	key = ftok(".", 1);
	if(key == -1)
	{
		perror("get key failedn");
		return -1;
	}

	int msg_id;

	msg_id = msgget(key, IPC_CREAT|0666);//不存在则创建，并设置权限为0666
	if(msg_id == -1)
	{
		perror("get msg id errorn");
		return -1;
	}

	struct msgbuf msg;
	int retval;

	while(1)
	{
		retval = msgrcv(msg_id,&msg, sizeof(msg), MSG_TYPE, IPC_NOWAIT);//IPC_NOWAIT，不等待，即不阻塞	    
		if((retval == -1)&&(errno != ENOMSG))//ENOMSG 还没有信息
		{
			perror("rcv errorn");
			return -1;
		}
		else if(retval != -1)
		{
			printf("[PID:%d], msg type:%ld, msg:%sn", msg.pid, msg.mtype, msg.mtext);
			if(strncmp(msg.mtext, "exit", 4) == 0)//可以指定长度为4时strlen(msg.mtext)才进行比较，仅仅对exit生效
			{
				break;
			}
		}
		

	}

	msgctl(msg_id, IPC_RMID, NULL);

	return 0;
}

send_a.c文件

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

#define MSG_TYPE_A	10
struct msgbuf 
{
    long mtype;       /* message type, must be > 0 */
    char mtext[100];    /* message data */
	int pid;
};


int main(void)
{
	key_t key;

	key = ftok(".", 1);
	if(key == -1)
	{
		perror("get key failedn");
		return -1;
	}

	int msg_id;

	msg_id = msgget(key, IPC_CREAT|0666);
	if(msg_id == -1)
	{
		perror("get msg id errorn");
		return -1;
	}

	char buffer[80];
	struct msgbuf msg;
	msg.mtype = MSG_TYPE_A;
	msg.pid = getpid();
	while(1)
	{
		
		fgets(msg.mtext, sizeof(msg.mtext), stdin);//含回车符

		msgsnd(msg_id, &msg, sizeof(msg), 0);	
				
		if(strncmp(msg.mtext, "exit", 4) == 0)
		{
			break;
		}
	}

	msgctl(msg_id, IPC_RMID, NULL);

	return 0;
}

send_b.c文件

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

#define MSG_TYPE_B	11
struct msgbuf 
{
    long mtype;       /* message type, must be > 0 */
    char mtext[100];    /* message data */
	int pid;
};


int main(void)
{
	key_t key;

	key = ftok(".", 1);
	if(key == -1)
	{
		perror("get key failedn");
		return -1;
	}

	int msg_id;

	msg_id = msgget(key, IPC_CREAT|0666);
	if(msg_id == -1)
	{
		perror("get msg id errorn");
		return -1;
	}

	char buffer[80];
	struct msgbuf msg;
	msg.mtype = MSG_TYPE_B;
	msg.pid = getpid();
	while(1)
	{
		
		fgets(msg.mtext, sizeof(msg.mtext), stdin);//含回车符

		msgsnd(msg_id, &msg, sizeof(msg), 0);	
				
		if(strncmp(msg.mtext, "exit", 4) == 0)
		{
			break;
		}
	}

	msgctl(msg_id, IPC_RMID, NULL);

	return 0;
}

        运行效果

三、共享内存 （shm：shared memory）

     在内核空间中开辟一片内存，并且将其映射到虚拟内存中使用。多个进程可对这一片共享内存进行单读写。

         使用共享内存的一般步骤是：
            1，获取共享内存对象的ID
            2，将共享内存映射至本进程虚拟内存空间的某个区域
            3，当不再使用时，解除映射关系
            4，当没有进程再需要这块共享内存时，删除它

        主要操作函数：

               int shmget(key_t key, size_t size, int shmflg);//获取或创建共享对象的ID号

               void *shmat(int shmid, const void *shmaddr, int shmflg);//映射共享内存到虚拟内存中

               int shmdt(const void *shmaddr);// 解除映射 

               int shmctl(int shmid, int cmd, struct shmid_ds *buf);//控制当前指定ID的共享内存信息

       3.1 shmget()函数

3.2 shmat()函数 和shmdt()函数

3.3   shmctl()函数

例子：shm_write进程进行写数据，shm_read进程进行读数据，shm_read进程在读取到一个数据后，写入ok后才进行读取数据。  shm_write进程写入exit后两个进程退出。

测试代码：

shm_write.c文件

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

#define SHM_SIZE	100

int main(void)
{
	key_t key;

	key = ftok(".", 1);
	if(key == -1)
	{
		perror("get key failedn");
		return -1;
	}

	int shm_id;

	shm_id = shmget(key, SHM_SIZE, IPC_CREAT|0666);
	if(shm_id == -1)
	{
		perror("get shm id errorn");
		return -1;
	}

	char *addr;

	addr = shmat(shm_id, NULL, 0);
	if(addr == (void *)-1)
	{
		perror("map address errorn");	
		return -1;
	}

	while(1)
	{
		fgets(addr, SHM_SIZE, stdin);
		if(strncmp(addr, "exit", 4) == 0)
		{
			break;
		}
		while( strncmp(addr, "ok", 2) != 0);
	}
	shmdt(addr);


	shmctl(shm_id , IPC_RMID, 0);

	return 0;
}

 shm_read.c文件

e <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <string.h>

#define SHM_SIZE	100

int main(void)
{
	key_t key;

	key = ftok(".", 1);
	if(key == -1)
	{
		perror("get key failedn");
		return -1;
	}

	int shm_id;

	shm_id = shmget(key, SHM_SIZE, IPC_CREAT|0666);
	if(shm_id == -1)
	{
		perror("get shm id errorn");
		return -1;
	}

	char *addr;

	addr = shmat(shm_id, NULL, 0);
	if(addr == (void *)-1)
	{
		perror("map address errorn");	
		return -1;
	}

	while(1)
	{
		while(strlen(addr) ==0 );
		printf("shm data=%sn", addr);
		if(strncmp(addr, "exit", 4) == 0)
		{
			break;
		}
		do
		{
			scanf("%s", addr);
		}while(strncmp(addr, "ok", 2) != 0);
		while(strncmp(addr, "ok", 2) == 0);

	}
	shmdt(addr);


	shmctl(shm_id , IPC_RMID, 0);

	return 0;
}

运行结果：

四、信号量 (sem)

       不是用来传输数据的，一般用来实现进程的同步互斥，就有点像是某个进程对一个值进行操作时，将某个标志置为正在使用，当另一个进程也想对该值进行操作时，看到这个标志，就会等待，直到可以操作。有点像是对一个全局变量进行操作，一个进行减操作(P操作),一个进行加操作(V操作)。P操作只有在信号量值>0才能成功，否则被阻塞，等待信号量值>0。比如信号量的值原来为1，进行P操作后变为0，然后在进行P操作时，由于信号量的值不满足>0,所以此时会被阻塞，直到信号量的值被其他进程改变为>0。一个信号量集合可以由多个信号量，通过索引编号进行操作一个或多个信号量的各自P、V操作。

     4.1 semget()函数

4.2 semop()函数

4.3 semctl()函数

例子：有两个进程，进程sem_p进行P操作，进程sem_v进行V操作。(sem_v回车，进行V操作之后，sem_p才能进行P操作)

这里旨在说明P、V操作的效果互斥，可以在不同的进程操作分别P、V操作。

测试代码

sem_p.c文件

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.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) */

};
	   
		   
int sem_opt_p(int sem_id, int sem_num)
{
	struct sembuf  semb[1];
	
	semb.sem_num = sem_num;	//信号量集合的下标
	semb.sem_op = -1;		//信号量进行何种运算,P操作
	semb.sem_flg = 0;		//0代表默认操作
	
	return semop(sem_id, &semb, 1);
	
}		   
	
int sem_opt_v(int sem_id, int sem_num)
{
	struct sembuf  semb[1];
	
	semb[0].sem_num = sem_num;
	semb[0].sem_op = 1;
	semb[0].sem_flg = 0;
	
	
	/*
		semop的第二个参数支持传输一个struct sembuf的数组
		第三个参数代表数组的个数
	*/
	return semop(sem_id, semb, 1);
	
}	
		   
		   
int main(void)
{

	key_t key;

	key = ftok(".", 1);
	if(key == -1)
	{
		perror("get key failedn");
		return -1;
	}

	int sem_id;

	/*
		函数：获取信号量的id
			1：申请1个信号量（信号量集合里面只有一个元素）
	*/
	sem_id = semget(key, 1, IPC_CREAT|0666);//不存在则创建
	if(sem_id == -1)
	{
		perror("get sem errorn");
		return -1;
	}

	union semun su;
	su.val = 1;	//设置初值为1
	semctl(sem_id, 0, SETVAL, su);

	int i = 5;
	while(i--)
	{
		sem_opt_p(sem_id, 0);
		printf("sem_opt_p successn");
		
	}
	
	semctl(sem_id, 0, IPC_RMID);//移除sem（IPC对象）

	return 0;
}

sem_v.c文件

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.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) */

};
	   
		   
int sem_opt_p(int sem_id, int sem_num)
{
	struct sembuf  semb[0];
	
	semb.sem_num = sem_num;	//信号量集合的下标
	semb.sem_op = -1;		//信号量进行何种运算,P操作
	semb.sem_flg = 0;		//0代表默认操作
	
	return semop(sem_id, &semb, 1);
	
}		   
	
int sem_opt_v(int sem_id, int sem_num)
{
	struct sembuf  semb[1];
	
	semb[0].sem_num = sem_num;
	semb[0].sem_op = 1;
	semb[0].sem_flg = 0;
	
	
	/*
		semop的第二个参数支持传输一个struct sembuf的数组
		第三个参数代表数组的个数
	*/
	return semop(sem_id, semb, 1);
	
}	
		   
		   
int main(void)
{

	key_t key;

	key = ftok(".", 1);
	if(key == -1)
	{
		perror("get key failedn");
		return -1;
	}

	int sem_id;

	/*
		函数：获取信号量的id
			1：申请1个信号量（信号量集合里面只有一个元素）
	*/
	sem_id = semget(key, 1, IPC_CREAT|0666);//不存在则创建
	if(sem_id == -1)
	{
		perror("get sem errorn");
		return -1;
	}


	int i = 4;
	while(i--)
	{
		getchar();
		sem_opt_v(sem_id, 0);
		printf("sem_op_v successn");
	}
	
	semctl(sem_id, 0, IPC_RMID);//移除sem（IPC对象）

	return 0;
}

运行结果：

例子2：多进程操作共享资源时候的情形，

测试代码：

/*****************************************************************************************
 * Project: sem test
 * File: sem.c
 * Date: 2020.10.1
 * Author: Genven_Liang
 * Description:test for sem p
 *****************************************************************************************/
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.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) */

};
	   

/*****************************************************************************************
 * 函数: sem_opt_p
 * 作用: sem P操作
 * 形参：int sem_id -> 信号量集合id
 *		 int sem_num -> 要操作的信号量索引
 * 返回：
 * 说明:
 *****************************************************************************************/		   
int sem_opt_p(int sem_id, int sem_num)
{
	struct sembuf semb[1];
	
	/* P操作 */
	semb[0].sem_num = sem_num;	//信号量集合的下标 信号量集合可以有多个信号量，根据数组下标进行指定要操作的信号量
	semb[0].sem_op = -1;		//信号量进行何种运算,P操作
	semb[0].sem_flg = SEM_UNDO;		//SEM_UNDO若程序退出后没有释放信号量资源，由系统释放 IPC_NOWAIT非阻塞	
	/*
		semop的第二个参数支持传输一个struct sembuf的数组
		第三个参数代表数组的个数
	*/
	return semop(sem_id, semb, 1);	//返回0成功
}		   

/*****************************************************************************************
 * 函数: sem_opt_v
 * 作用: sem V操作
 * 形参：int sem_id -> 信号量集合id
 *		 int sem_num -> 要操作的信号量索引
 * 返回：
 * 说明:
 *****************************************************************************************/		
int sem_opt_v(int sem_id, int sem_num)
{
	struct sembuf semb[1];
	
	/* V操作 */
	semb[0].sem_num = sem_num;
	semb[0].sem_op = 1;
	semb[0].sem_flg = SEM_UNDO;//SEM_UNDO若程序退出后没有释放信号量资源，由系统释放 IPC_NOWAIT非阻塞	
	return semop(sem_id, semb, 1);	//返回0成功
}	
		   
		   
int main(int argc, char **argv)
{
	int ret;
	key_t key;

	/* 1 获取key */
	key = ftok(".", 1); /* 根据当前路径获取key，也可以直接指定key为某个数值 */
	if (-1 == key) {
		perror("get key failedn");
		return -1;
	} else {
		printf("key_t:0x%08xn", key);
	}

	/* 2 获取信号量集合的id */
	int sem_id;
	sem_id = semget(key, 1, IPC_CREAT|0666);//不存在则创建
	if (-1 == sem_id) {
		perror("get sem errorn");
		return -1;
	} else {
		printf("sem_id:%dn", sem_id);
	}

	if (argc >= 2) {
		/* 设置信号量0初值 */
		//设置初值为1 注意信号量值大于0才能进行sem_op_p 操作，不然会默认阻塞等待
		union semun su;
		su.val = 1;	
		if (-1 == semctl(sem_id, 0, SETVAL, su)) {
			semctl(sem_id, 0, IPC_RMID);//移除sem（IPC对象）
			printf("init sem value failed.n");
			return -1;
		} else {
			printf("init sem value success.n");
		}
	}

	/* 3 操作临界资源 */
	int i = 2;
	
	while(i--) {
		printf("wait for sem pn");
		ret = sem_opt_p(sem_id, 0); /* P操作上锁 */
		if (0 == ret) {
			printf("sem p.n");

			fflush(stdin);/* 手动控制时间，模拟操作共享资源的耗时、两个进程共同操作同一个资源的情况 */
			getchar();		

			printf("op resources.n");/* 操作共享资源 */

			fflush(stdin);/* 手动控制时间，模拟操作共享资源的耗时、两个进程共同操作同一个资源的情况 */
			getchar();

			ret = sem_opt_v(sem_id, 0); /* V操作解锁 */	
			if (0 == ret) {
				printf("sem v.n");/* 操作共享资源 */
			} else {
				printf("sem v failed.n");
			}
		} else {
			printf("sem p failed.n");
		}

		fflush(stdin);/* 手动控制时间，模拟操作共享资源的耗时、两个进程共同操作同一个资源的情况 */
		getchar();		
	}
	
	/* 4 释放资源 */
	ret = semctl(sem_id, 0, IPC_RMID);//移除sem（IPC对象）
	printf("IPC_RMID ret:%dn", ret);

	return 0;
}

测试效果：

sem结合shm使用例子：sema进程写入信息，semb进程读取信息

sema.c文件

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

#define SHM_SIZE	100
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 sem_opt_p(int sem_id, int sem_num)
{
	struct sembuf  semb[1];
	
	semb.sem_num = sem_num;	//信号量集合的下标
	semb.sem_op = -1;		//信号量进行何种运算，P操作
	semb.sem_flg = 0;		//0代表默认操作
	
	return semop(sem_id, &semb, 1);
	
}		   
	
int sem_opt_v(int sem_id, int sem_num)
{
	struct sembuf  semb[1];
	
	semb[0].sem_num = sem_num;
	semb[0].sem_op = 1;
	semb[0].sem_flg = 0;
	
	
	/*
		semop的第二个参数支持传输一个struct sembuf的数组
		第三个参数代表数组的个数
	*/
	return semop(sem_id, semb, 1);
	
}	
		   
		   
int main(void)
{

	key_t key;

	key = ftok(".", 1);
	if(key == -1)
	{
		perror("get key failedn");
		return -1;
	}

	int sem_id;

	/*
		函数：获取信号量的id
			1：申请1个信号量（信号量集合里面只有一个元素）
	*/
	sem_id = semget(key, 2, IPC_CREAT|0666);
	if(sem_id == -1)
	{
		perror("get sem errorn");
		return -1;
	}

	int shm_id;
	shm_id = shmget(key, SHM_SIZE, IPC_CREAT|0666);//共享内存与信号量可使用同一个key值
	if(shm_id == -1)
	{
		perror("get shm errorn");
		return -1;
	}

	char *addr;
	addr = shmat( shm_id, NULL, 0);

	union semun su;
	su.val = 1;	//设置信号量0初值为1
	semctl(sem_id, 0, SETVAL, su);

	su.val = 0;//设置信号量1初值为0
	semctl(sem_id, 1, SETVAL, su);

	
	while(1)
	{
		sem_opt_p(sem_id, 0);//P操作，若信号量0值<0 则阻塞。
        
		printf("start inputn");
		
		fgets(addr, SHM_SIZE, stdin);
		sem_opt_v(sem_id, 1);//不阻塞信号量1的P操作
		
		if(strncmp(addr, "exit", 4) == 0)
		{
			break;
		}
		
		
	}
	
	shmctl(shm_id , IPC_RMID, 0);
	semctl(sem_id, 0, IPC_RMID);

	return 0;
}

semb.c文件

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

#define SHM_SIZE	100
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 sem_opt_p(int sem_id, int sem_num)
{
	struct sembuf  semb[1];
	
	semb.sem_num = sem_num;	//信号量集合的下标
	semb.sem_op = -1;		//信号量进行何种运算，P操作
	semb.sem_flg = 0;		//0代表默认操作
	
	return semop(sem_id, &semb, 1);
	
}		   
	
int sem_opt_v(int sem_id, int sem_num)
{
	struct sembuf  semb[1];
	
	semb[0].sem_num = sem_num;
	semb[0].sem_op = 1;
	semb[0].sem_flg = 0;
	
	
	/*
		semop的第二个参数支持传输一个struct sembuf的数组
		第三个参数代表数组的个数
	*/
	return semop(sem_id, semb, 1);
	
}	
		   
		   
int main(void)
{

	key_t key;

	key = ftok(".", 1);
	if(key == -1)
	{
		perror("get key failedn");
		return -1;
	}

	int sem_id;

	/*
		函数：获取信号量的id
			2：申请2个信号量（信号量集合里面只有一个元素）
	*/
	sem_id = semget(key, 2, IPC_CREAT|0666);
	if(sem_id == -1)
	{
		perror("get sem errorn");
		return -1;
	}

	int shm_id;

	shm_id = shmget(key, SHM_SIZE, IPC_CREAT|0666);
	if(shm_id == -1)
	{
		perror("get shm errorn");
		return -1;
	}

	char *addr;
	addr = shmat( shm_id, NULL, 0);
	
	while(1)
	{
		sem_opt_p(sem_id, 1);//对信号量1进行P操作(成功操作则使得信号量1的下次P操作阻塞，否则就等待)

		printf("addr=%s", addr);
		if(strncmp(addr, "exit", 4) == 0)
		{
			break;
		}
		
		sem_opt_v(sem_id, 0);//对信号量0进行V操作(使得信号量0的下次P操作不阻塞)
	}
	
	shmctl(shm_id , IPC_RMID, 0);
	semctl(sem_id, 0, IPC_RMID);

	return 0;
}

运行效果：

posix标准信号量：有名信号量、匿名信号量(待补充)

 其中有名信号量的特点：
                1，它每次只能操作一个信号量
                2，每次操作只能+1或者-1
                3，简单直接(高度封装IPC的sem)
                4，有文件诞生    /dev/shm/sem.xxx      (xxx是有名信号量的名称)

 主要函数：

   1、sem_open()：用来打开或创建一个posix有名信号量。

   2、sem_close()：关闭一个posix有名信号量。

   3、sem_wait()：P操作（减操作）。

   4、sem_post：V操作（加操作）。

   5、sem_unlink()：移除信号量，释放系统资源。

例子：posix_sem_p进程进行P操作，posix_sem_v进程进行V操作。（posix_sem_v进程每回车一次进行V操作)

posix_sem_p.c文件

#include <stdio.h>
#include <fcntl.h>           /* For O_* constants */
#include <sys/stat.h>        /* For mode constants */
#include <semaphore.h>

int main(void)
{
	sem_t *st;

	st = sem_open("mysem", O_CREAT, 0666, 1);
	if(st == SEM_FAILED)
	{
		perror("open sem errorn");
		return -1;
	}

	int i = 5;
	while(i--)
	{
		sem_wait(st);//p操作
		printf("sem_wait opt p successn");
	}


	sem_close(st);
	sem_unlink("mysem");
	return 0;
}

posix_sem_v.c文件

#include <stdio.h>
#include <fcntl.h>           /* For O_* constants */
#include <sys/stat.h>
#include <semaphore.h>


int main(void)
{
	sem_t *st;

	st = sem_open("mysem", O_RDWR);
	if(st == SEM_FAILED)
	{
		perror("open sem errorn");
		return -1;
	}

	int i = 4;
	while(i--)
	{
		getchar();
		sem_post(st);//v操作
		printf("sem_post opt v successn");
	}

	sem_close(st);
	sem_unlink("mysem");
	return 0;
}

运行效果：

最后

以上就是美丽猫咪为你收集整理的Linux-C 进程通信之system-V IPC的全部内容，希望文章能够帮你解决Linux-C 进程通信之system-V IPC所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。