如何在linux下看消息队列是否存在

#include

#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_

Linux信号量(semaphore)是一种互斥机制。即对某个互斥资源的访问会收到信号量的保护，在访问之前需要获得信号量。

在 *** 作完共享资源后，需释放信号量，以便另外的进程来获得资源。获得和释放应该成对出现。

获得信号量集，需要注意的是，获得的是一个集合，而不是一个单一的信号量。

#include

#include

#include

1: int semget(key_t key,int nsems,int semflg)

key:系统根据这个值来获取信号量集。

nsems:此信号集包括几个信号量。

semflg:创建此信号量的属性。 （IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)

成功则返回该信号量集的ID。

注：

既指定IPC_CREAT又指定IPC_EXCL时，如果系统中该信号量集已经存在，则马上返回。

如果需要获得存在的信号量，则将此参数置0.

2: int semctl(int semid,int senum,int cmd....)

semid:信号量ID。

senum:对信号量集中的第几个信号量进行控制。（从0开始）

cmd:需要进行的 *** 作。（SETVAL是其中的一个）。

根据cmd的不同可能存在第四个参数，cmd=SETVAL时，表示同时信号量可以被获得几次，如第四个参数

num=1表示只能被获得一次，既被信号量保护的资源只能同时被一个程序使用。

该系统调用，是在对信号量初始化时用的。

-3： “3”前面加了"-"表示当需要使用互斥资源时应该做这步。

int semop(int semid,struct sembuf *sem,int num_elements)

struct sembuf {

unsigned short sem_num //该信号量集中的第几个信号量。

int sem_op//需要获得还是释放信号量

int sem_flg//相关动作

}

num_elements:需要对该信号量集中的多少个信号量进行处理。

获得信号量时，将sembuf结构提初始化为：

sem_num = 0//该信号量集中的首个信号量

sem_op = -1//获得信号量

sem_flag = IPC_NOWAIT //如果不能获得信号量，马上返回。

semop(semid,_sem,1)

同理释放信号量时，将sem_op设为1.

以上是对信号量的简单处理

---