#include
#include
#include types.h>
#include msg.h>
#include
#include ipc.h>
void msg_show_attr(int msg_id, struct msqid_ds msg_info)
{
int ret = -1
sleep(1)
ret = msgctl(msg_id, IPC_STAT, &msg_info)
if( -1 == ret)
{
printf(获消息信息失败\n)
return
}
printf(\n)
printf(现队列字节数：%d\n,msg_info.msg_cbytes)
printf(队列消息数：%d\n,msg_info.msg_qnum)
printf(队列字节数：%d\n,msg_info.msg_qbytes)
printf(发送消息进程pid：%d\n,msg_info.msg_lspid)
printf(接收消息进程pid：%d\n,msg_info.msg_lrpid)
printf(发送消息间：%s,ctime(&(msg_info.msg_stime)))
printf(接收消息间：%s,ctime(&(msg_info.msg_rtime)))
printf(变化间：%s,ctime(&(msg_info.msg_ctime)))
printf(消息UID：%d\n,msg_info.msg_perm.uid)
printf(消息GID：%d\n,msg_info.msg_perm.gid)
}
int main(void)
{
int ret = -1
int msg_flags, msg_id
key_t key
struct msgmbuf{
int mtype
char mtext[10]
}
struct msqid_ds msg_info
struct msgmbuf msg_mbuf
int msg_sflags,msg_rflags
char *msgpath = /ipc/msg/
key = ftok(msgpath,’a')
if(key != -1)
{
printf(功建立KEY\n)
}
else
{
printf(建立KEY失败\n)
}
msg_flags = IPC_CREAT
msg_id = msgget(key, msg_flags|0666)
if( -1 == msg_id)
{
printf(消息建立失败\n)
return 0
}
msg_show_attr(msg_id, msg_info)
msg_sflags = IPC_NOWAIT
msg_mbuf.mtype = 10
memcpy(msg_mbuf.mtext,测试消息,sizeof(测试消息))
ret = msgsnd(msg_id, &msg_mbuf, sizeof(测试消息), msg_sflags)
if( -1 == ret)
{
printf(发送消息失败\n)
}
msg_show_attr(msg_id, msg_info)
msg_rflags = IPC_NOWAIT|MSG_NOERROR
ret = msgrcv(msg_id, &msg_mbuf, 10,10,msg_rfla
共享内存示例代码：
#include
#include sem.h>
#include ipc.h>
#include
typedef int sem_t
union semun {
int val
struct semid_ds *buf
unsigned short *array
} arg
sem_t CreateSem(key_t key, int value)
{
union semun sem
sem_t semid
sem.val = value
semid = semget(key,value,IPC_CREAT|0666)
if (-1 == semid)
{
printf(create semaphore error\n)
return -1
}
semctl(semid,0,SETVAL,sem)
return semid
}
/*
struct sembuf{
ushort sem_num
short sem_op
short sem_flg
}
*/
void SetvalueSem(sem_t semid, int value)
{
union semun sem
sem.val = value
semctl(semid,0,SETVAL,sem)
return
}
int GetvalueSem(sem_t semid)
{
union semun sem
return semctl(semid,0,GETVAL,sem)
return sem.val
}
void DestroySem(sem_t semid)
{
union semun sem
sem.val = 0
semctl(semid,0,IPC_RMID,sem)
}
int Sem_P(sem_t semid)
{
struct sembuf sops={0,+1,IPC_NOWAIT}
return (semop(semid,&sops,1))
}
int Sem_V(sem_t semid)
{
struct sembuf sops={0,-1,IPC_NOWAIT}
return (semop(semid,&sops,1))
}
static char msg[]=共享内存\n
int main(void)
{
key_t key
int semid,shmid
char i,*shms,*shmc
struct semid_ds buf
int value = 0
char buffer[80]
pid_t p
key = ftok(/ipc/sem/,’a')
shmid = shmget(key,1024,IPC_CREAT|0604)
semid = CreateSem(key,1)
p = fork()
if(p >0)
{
/* 父进程 */
/* 建立共享内存 */
shms = (char *)shmat(shmid,0,0)
memcpy(shms, msg, strlen(msg)+1)
sleep(10)
Sem_P(semid)
shmdt(shms)
DestroySem(semid)
}
else if(p == 0)
{
shmc = (char *)shmat(shmid,0,0)
Sem_V(semid)
printf(共享内存值:%s\n,shmc)
shmdt(sg_
信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。为了完成这个过程，需要创建一个信号量VI，然后将Acquire Semaphore VI以及Release Semaphore VI分别放置在每个关键代码段的首末端。确认这些信号量VI引用的是初始创建的信号量。描述
编辑
以一个停车场的运作为例。简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆直接进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一辆车离开停车场，看门人得知后，打开车拦，放入外面的一辆进去，如果又离开两辆，则又可以放入两辆，如此往复。
在这个停车场系统中，车位是公共资源，每辆车好比一个线程，看门人起的就是信号量的作用。
分类
编辑
整型信号量（integer semaphore)：信号量是整数
记录型信号量（record semaphore)：每个信号量s除一个整数值s.value（计数）外，还有一个进程等待队列s.L，其中是阻塞在该信号量的各个进程的标识
二进制信号量(binary semaphore)：只允许信号量取0或1值
每个信号量至少须记录两个信息：信号量的值和等待该信号量的进程队列。它的类型定义如下：（用类PASCAL语言表述）
semaphore = record
value: integer
queue: ^PCB
end
其中PCB是进程控制块，是操作系统为每个进程建立的数据结构。
s.value>=0时，s.queue为空；
s.value<0时，s.value的绝对值为s.queue中等待进程的个数；
特性
编辑
抽象的来讲，信号量的特性如下：信号量是一个非负整数（车位数），所有通过它的线程/进程（车辆）都会将该整数减一（通过它当然是为了使用资源），当该整数值为零时，所有试图通过它的线程都将处于等待状态。在信号量上我们定义两种操作： Wait（等待） 和 Release（释放）。当一个线程调用Wait操作时，它要么得到资源然后将信号量减一，要么一直等下去（指放入阻塞队列），直到信号量大于等于一时。Release（释放）实际上是在信号量上执行加操作，对应于车辆离开停车场，该操作之所以叫做“释放”是因为释放了由信号量守护的资源。
操作方式
编辑
对信号量有4种操作(include<semaphore>)：
1. 初始化（initialize），也叫做建立（create） int sem_init(sem_t *sem, int pshared, unsigned int value)
2. 等信号（wait），也可叫做挂起（suspend）int sem_wait(sem_t *sem)
3. 给信号（signal）或发信号（post） int sem_post（sem_t *sem）
4.清理（destroy） int sem_destory(sem_t *sem)[1]
创建
编辑
同共享内存一样，系统中同样需要为信号量集定制一系列专有的操作函数（semget，semctl等）。系统命令ipcs可查看当前的系统IPC的状态，在命令后使用-s参数。使用函数semget可以创建或者获得一个信号量集ID，函数原型如下：
#include <sys/shm.h>
int semget( key_t key, int nsems, int flag)
函数中参数key用来变换成一个标识符，每一个IPC对象与一个key相对应。当新建一个共享内存段时，使用参数flag的相应权限位对ipc_perm结构中的mode域赋值，对相应信号量集的shmid_ds初始化的值如表1所示。
shmid_ds结构初始化值表
ipc_perm结构数据
初 值
ipc_perm结构数据
初 值
Sem_otime
0
Sem_nsems
Nsems
Sem_ctime
系统当前值
参数nsems是一个大于等于0的值，用于指明该信号量集中可用资源数（在创建一个信号量时）。当打开一个已存在的信号量集时该参数值为0。函数执行成功，则返回信号量集的标识符（一个大于等于0的整数），失败，则返回–1。函数semop用以操作一个信号量集，函数原型如下：
#include <sys/sem.h>
int semop( int semid, struct sembuf semoparray[], size_t nops )
函数中参数semid是一个通过semget函数返回的一个信号量标识符，参数nops标明了参数semoparray所指向数组中的元素个数。参数semoparray是一个struct sembuf结构类型的数组指针，结构sembuf来说明所要执行的操作，其定义如下：
struct sembuf{
unsigned short sem_num
short sem_op
short sem_flg
}
在sembuf结构中，sem_num是相对应的信号量集中的某一个资源，所以其值是一个从0到相应的信号量集的资源总数（ipc_perm.sem_nsems）之间的整数。sem_op指明所要执行的操作，sem_flg说明函数semop的行为。sem_op的值是一个整数，如表2所示，列出了详细sem_op的值及所对应的操作。
sem_op值详解
Sem_op
操 作
正数
释放相应的资源数，将sem_op的值加到信号量的值上
0
进程阻塞直到信号量的相应值为0，当信号量已经为0，函数立即返回。如果信号量的值不为0，则依据sem_flg的IPC_NOWAIT位决定函数动作。sem_flg指定IPC_NOWAIT，则semop函数出错返回EAGAIN。sem_flg没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生。信号量值为0，将信号量的semzcnt的值减1，函数semop成功返回；此信号量被删除（只有超级用户或创建用户进程拥有此权限），函数smeop出错返回EIDRM；进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR
负数
请求sem_op的绝对值的资源。如果相应的资源数可以满足请求，则将该信号量的值减去sem_op的绝对值，函数成功返回。当相应的资源数不能满足请求时，这个操作与sem_flg有关。sem_flg指定IPC_NOWAIT，则semop函数出错返回EAGAIN。sem_flg没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：当相应的资源数可以满足请求，该信号的值减去sem_op的绝对值。成功返回；此信号量被删除（只有超级用户或创建用户进程拥有此权限），函数smeop出错返回EIDRM：进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR
基本流程
编辑
下面实例演示了关于信号量操作的基本流程。程序中使用semget函数创建一个信号量集，并使用semop函数在这个信号集上执行了一次资源释放操作。并在shell中使用命令查看系统IPC的状态。
（1）在vi编辑器中编辑该程序。
程序清单14-10 create_sem.c 使用semget函数创建一个信号量
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
int main( void )
{
int sem_id
int nsems = 1
int flags = 0666
struct sembuf buf
sem_id = semget(IPC_PRIVATE, nsems, flags)/*创建一个新的信号量集*/
if ( sem_id <0 ){
perror( "semget ")
exit (1 )
}
/*输出相应的信号量集标识符*/
printf ( "successfully created a semaphore : %d\n", sem_id )
buf.sem_num = 0/*定义一个信号量操作*/
buf.sem_op = 1/*执行释放资源操作*/
buf.sem_flg = IPC_NOWAIT/*定义semop函数的行为*/
if ( (semop( sem_id, &buf, nsems) ) <0) { /*执行操作*/
perror ( "semop")
exit (1 )
}
system ( "ipcs -s " )/*查看系统IPC状态*/
exit ( 0 )
}
（2）在vmware中编译该程序如下：
gcc -o a.o testc_semaphore.c
（3）在shell中运行该程序如下：
./a3.o
successfully created a semaphore : 0
------ Semaphore Arrays --------
key semid owner perms nsems
0x00000000 0 zcr 666 1
在上面程序中，用semget函数创建了一个信号量集，定义信号量集的资源数为1，接下来使用semop函数进行资源释放操作。在程序的最后使用shell命令ipcs来查看系统IPC的状态。
%注意：命令ipcs参数-s标识查看系统IPC的信号量集状态。
希望能帮到你，满意望采纳哦。
一、简介共享内存为在多个进程之间共享和传递数据提供了一种有效的方式。
但它本身并未提供同步机制。
在实际编程中，可以使用
信号量，
传递消息(使用管道或IPC消息)，
生成信号，
条件变量，
等方法来提供读写之间的有效的同步机制。
本例程序使用信号量进行同步，
主要是因为它方便，使用广泛，且独立于进程。
本例程序实现了，
生产者进程:
每次读取YUV输入文件的一帧，
然后将其写到共享内存中。
消费者进程:
每次从共享内存中读到一帧，
处理后，
将其写到输出文件。
两个进程间使用信号量来保证同步处理每一帧。
本例程序很好地示范了共享内存和信号量的机制，
对于实际程序的开发很有意义。
二、生产者进程
common.h
用来设置一些测试用的基本参数。
/*
* \File
* common.h
*/
#ifndef __COMMON_H__
#define __COMMON_H__
#define TEST_FILE "coastguard_cif.yuv"
#define OUTPUT_FILE "coastguard_cif_trsd.yuv"
#define FYUV_WIDTH 352
#define FYUV_HEIGHT 288
#endif
共享内存相关的头文件。
shm_com.h
/*
* \File
* shm_com.h
* \Brief
*/
#ifndef __SHM_COM_H__
#define __SHM_COM_H__
#define SHM_SEED 1001
#define MAX_SHM_SIZE 2048*2048*3
typedef struct shared_use_st
{
int end_flag //用来标记进程间的内存共享是否结束: 0, 未结束； 1， 结束
char shm_sp[MAX_SHM_SIZE]//共享内存的空间
}shared_use_st
#endif
信号量的头文件
semaphore.h
/*
* \File
* semaphore.h
* \Brief
* semaphore operation
*/
#ifndef __SEMAPHORE_H__
#define __SEMAPHORE_H__
#define SEM_SEED 1000
union semun
{
int val
struct semid_ds *buf
unsigned short *array
}
int set_semvalue(int sem_id, int value)
void del_semvalue(int sem_id)
int semaphore_p(int sem_id)
int semaphore_v(int sem_id)
#endif
帧处理的头文件
frame.h
/*
* \File
* frame.h
* \Brief
*
*/
#ifndef __FRAME_H__
#define __FRAME_H__
#include "shm_com.h"
#define PIX_VALUE 1
typedef enum
{
YUV420,
YUV422,
YUV444,
RGB
}frame_type_e
typedef struct
{
int frm_w// width
int frm_h// height
frame_type_e frm_type
int frm_size
char *frm_comps
}frame_t, *frame_p
int init_frame(frame_p frame, int width, int height, frame_type_e type)
int free_frame(frame_p frame)
int read_frame_from_file(frame_p frame, FILE* fp)
int write_frame_into_file(FILE* fp, frame_p frame)
int read_frame_from_shm(frame_p frame, shared_use_st* shm)
int write_frame_into_shm(shared_use_st* shm, frame_p frame)
int crop_frame(frame_p frame, int l_offset, int t_offset, int c_w, int c_h)
#endif
生产者进程的基本流程:
打开输入文件并初始化帧
创建并初始化共享内存和信号量
然后每次读取一帧，
用信号量获取共享内存的权限后，
将读取的帧写入共享内存，
再释放共享内存的权限。
当处理完所有的帧后，
设置结束标志，
并释放相关的资源。
producer.c
/*
* \File
* producer.c
* \Brief
* Test shared-memory and message-queue
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include "common.h"
#include "semaphore.h"
#include "shm_com.h"
#include "frame.h"
int main(char argc, char* argv[])
{
FILE* fp_in = NULL
frame_t frame
int frame_cnt = 0
int sem_id// semaphore id
int shm_id// shared-memory id
void* shared_memory = (void*)0
shared_use_st* shared_stuff
/* Open input file */
if ((fp_in = fopen(TEST_FILE, "rb")) <0 )
{
printf("Open input file failed: %s\n", TEST_FILE)
exit(EXIT_FAILURE)
}
/* Init frame */
init_frame(&frame, FYUV_WIDTH, FYUV_HEIGHT, YUV420)
printf("FRAME: w = %d, h = %d\n", frame.frm_w, frame.frm_h)
/* Create and init semaphore */
sem_id = semget((key_t)SEM_SEED, 1, 0666 | IPC_CREAT)
if (sem_id == -1)
{
fprintf(stderr, "semget failed.\n")
exit(EXIT_FAILURE)
}
/* Init shared-memory */
shm_id = shmget((key_t)SHM_SEED, sizeof(struct shared_use_st), 0666 | IPC_CREAT)
if (shm_id == -1)
{
fprintf(stderr, "shmget failed.\n")
exit(EXIT_FAILURE)
}
shared_memory = shmat(shm_id, (void*)0, 0)
if (shared_memory == (void*)-1)
{
fprintf(stderr, "shmat failed.\n")
exit(EXIT_FAILURE)
}
shared_stuff = (struct shared_use_st*)shared_memory
shared_stuff->end_flag = 0
printf("FRAME_CNT: %d\n", frame_cnt)
set_semvalue(sem_id, 1)
while (read_frame_from_file(&frame, fp_in) == 0)
{
semaphore_p(sem_id)
/* Write it into shared memory */
write_frame_into_shm(shared_stuff, &frame)
shared_stuff->end_flag = 0
semaphore_v(sem_id)
frame_cnt++
printf("FRAME_CNT: %d\n", frame_cnt)
}
semaphore_p(sem_id)
shared_stuff->end_flag = 1
semaphore_v(sem_id)
/* over */
printf("\nProducer over!\n")
fclose(fp_in)
free_frame(&frame)
del_semvalue(sem_id)
if (shmdt(shared_memory) == -1)
{
fprintf(stderr, "shmdt failed.\n")
exit(EXIT_FAILURE)
}
exit(EXIT_SUCCESS)
}
欢迎分享，转载请注明来源：夏雨云
微信扫一扫
支付宝扫一扫
评论列表（0条）