管道、信号 Unix
1.消息队列、共享内存、信号灯 SYS V
IPC对象：
内存文件
1.ipcs
查看所有ipc对象的信息
2.ipcrm
ipcrm -Q/M/S Key
ipcrm -q/m/s 消息队列ID/共享内存ID/信号灯ID
1.消息队列：
1.创建IPC对象名称
2.创建消息队列
3.发送消息
4.接收消息
5.消息队列销毁
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 | #include "../head.h" typedef struct msg { long mtype; //发送消息的类型 char mtext[256]; //发送的消息 }message_t; int main(void) { key_t key; int msgid = -1; int ret = 0; message_t sendmsg; message_t recvmsg; ssize_t nsize = 0; //1.生成key值 key = ftok("/", 'a'); if (-1 == key) { return -1; } printf("%#x\n", key); //2.创建消息队列 msgid = msgget(key, IPC_CREAT | 0664); if (-1 == msgid) { return -1; } printf("msgid = %d\n", msgid); //3.发送消息 sendmsg.mtype = 100; strcpy(sendmsg.mtext, "hello world"); ret = msgsnd(msgid, &sendmsg, sizeof(sendmsg) - sizeof(long), 0); if (-1 == ret) { return -1; } printf("发送成功!\n"); sendmsg.mtype = 200; strcpy(sendmsg.mtext, "how are you"); ret = msgsnd(msgid, &sendmsg, sizeof(sendmsg) - sizeof(long), 0); if (-1 == ret) { return -1; } printf("发送成功!\n"); nsize = msgrcv(msgid, &recvmsg, sizeof(recvmsg.mtext), 100, 0); if (-1 == nsize) { return -1; } printf("接收到 %ld 字节,内容为: %s\n", nsize, recvmsg.mtext); msgctl(msgid, IPC_RMID, NULL); return 0; } |
2.函数接口:
1.ftok
key_t ftok(const char *pathname, int proj_id);
功能：
创建一个IPC对象名称
参数：
pathname:文件的路径
proj_id:项目ID（8bits）
返回值：
成功返回IPC对象名称
失败返回-1
2.msgget
int msgget(key_t key, int msgflg);
功能：
创建一个消息队列
参数：
key:IPC对象名称
msgflg:消息队列属性
IPC_CREAT：创建一个消息队列
IPC_EXCL: 如果消息队列存在就报错
返回值：
成功返回消息队列ID
失败返回 -1
3.msgsnd
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
功能：
向消息队列中发送消息
参数：
msqid:消息队列的ID号
msgp:发送消息的内容
msgsz:发送消息的大小
msgflg:消息属性 默认为0
返回值：
成功返回0
失败返回-1
struct msgbuf {
long mtype; /* message type, must be > 0 */
char mtext[1]; /* message data */
};
4.msgrcv
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
功能：
从消息队列中接收消息
参数:
msqid:消息队列的ID号
msgp:存放消息的空间首地址
msgsz:最多接收消息的大小
msgtyp:接收消息的类型
msgflg:消息属性 默认为0
返回值：
成功返回接收到数据的字节数
失败返回-1
5.msgctl
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
功能:
向消息队列发送命令
参数:
msqid:消息队列的ID号
cmd:命令
IPC_STAT：获取消息队列的信息
返回值:
成功返回0
失败返回-1
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | #include "../head.h" int main(void) { key_t key; int msgid; int ret = 0; message_t sendmsg; //1.创建IPC对象 Key 值 key = ftok("/", 'b'); if (-1 == key) { perror("fail to ftok"); return -1; } //2.创建消息队列 msgid = msgget(key, IPC_CREAT | 0664); if (-1 == msgid) { perror("fail to shmget"); return -1; } sendmsg.mtype = 100; fgets(sendmsg.mtext, sizeof(sendmsg.mtext), stdin); sendmsg.mtext[strlen(sendmsg.mtext)-1] = '\0'; //3.发送消息 ret = msgsnd(msgid, &sendmsg, sizeof(sendmsg.mtext), 0); if (-1 == ret) { perror("fail to msgsnd"); return -1; } return 0; } |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 | #include "../head.h" int main(void) { key_t key; int msgid; ssize_t nsize = 0; message_t recvmsg; //1.创建IPC对象 Key 值 key = ftok("/", 'b'); if (-1 == key) { perror("fail to ftok"); return -1; } //2.创建消息队列 msgid = msgget(key, IPC_CREAT | 0664); if (-1 == msgid) { perror("fail to shmget"); return -1; } //3.接收消息 nsize = msgrcv(msgid, &recvmsg, sizeof(recvmsg.mtext), 100, 0); if (-1 == nsize) { perror("fail to msgrcv"); return -1; } //4.打印消息 printf("RECV:%s\n", recvmsg.mtext); //5.删除消息队列 msgctl(msgid, IPC_RMID, NULL); return 0; } |
练习：
1.编写两个进程，实现利用消息队列的通信
send.c 创建消息队列 -> 发送消息
recv.c 创建消息队列 -> 接收消息 -> 销毁消息队列
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 | #include "../head.h" int main(void) { //1.创建 key 值 key_t key; int shmid = 0; int ret = 0; char *pshmaddr = NULL; key = ftok("/", 'c'); if (-1 == key) { perror("fail to ftok"); return -1; } //2.创建共享内存 shmid = shmget(key, 4096, IPC_CREAT | 0664); if (-1 == shmid) { perror("fail to shmget"); return -1; } //3.映射到共享内存中 pshmaddr = shmat(shmid, NULL, 0); if (NULL == pshmaddr) { perror("fail to shmat"); return -1; } fgets(pshmaddr, 4096, stdin); pshmaddr[strlen(pshmaddr)-1] = '\0'; printf("共享空间: %s\n", pshmaddr); //4.解除映射 ret = shmdt(pshmaddr); if (-1 == ret) { perror("fail to shmdt"); return -1; } //5.销毁共享空间 shmctl(shmid, IPC_RMID, NULL); return 0; } |
共享内存：
进程间通信最高效的方法
操作步骤：
1.创建 key 值
2.创建共享内存
3.映射共享内存
4.解除映射
5.销毁共享内存
1.函数接口:
1.ftok
2.shmget
int shmget(key_t key, size_t size, int shmflg);
功能:
创建一个共享内存
参数:
key:IPC对象名称
size:共享内存的大小
shmflg:
IPC_CREAT 创建
IPC_EXCL 如果存在就报错
返回值:
成功返回共享内存ID号
失败返回-1
3.shmat
void *shmat(int shmid, const void *shmaddr, int shmflg);
功能:
将地址映射到共享内存中
参数:
shmid:共享内存ID号
shmaddr:
NULL: 让系统选择一个合适的地址映射到共享内存中
shmflg:
属性,默认为0
返回值:
成功返回映射到共享空间的地址
失败返回NULL
4.shmdt
int shmdt(const void *shmaddr);
功能:
解除映射空间
参数:
shmaddr:映射到共享内存中的地址
返回值:
成功返回0
失败返回-1
5.shmctl
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
功能:
向共享内存发送命令
参数:
shmid:共享内存ID号
cmd:命令
IPC_RMID 删除
返回值:
成功返回0
失败返回-1
练习：
1.编写两个进程，实现利用共享内存的通信
write.c 创建共享内存 -> 映射 -> 从终端接收数据写入共享内存中
read.c 创建共享内存 -> 映射 -> 从共享内存中读取数据 -> 显示到终端
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | #include "../head.h" int main(void) { int ret = 0; int shmid = 0; char *pshmaddr = NULL; //1.创建 key 值 key_t key; key = ftok("/", 'a'); if (-1 == key) { perror("fail to ftok"); return -1; } //2.创建共享内存 shmid = shmget(key, 4096, IPC_CREAT | 0664); if (-1 == shmid) { perror("fail to shmget"); return -1; } //3.映射共享内存空间 pshmaddr = shmat(shmid, NULL, 0); if (NULL == pshmaddr) { perror("fail to shmat"); return -1; } while (1) { printf("内容:%s\n", pshmaddr); if (!strcmp(pshmaddr, ".quit")) { break; } } //4.解除映射 ret = shmdt(pshmaddr); if (-1 == ret) { perror("fail to shmdt"); return -1; } //5.删除共享内存 shmctl(shmid, IPC_RMID, NULL); return 0; } |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 | #include "../head.h" int main(void) { int ret = 0; int shmid = 0; char *pshmaddr = NULL; //1.创建 key 值 key_t key; key = ftok("/", 'a'); if (-1 == key) { perror("fail to ftok"); return -1; } //2.创建共享内存 shmid = shmget(key, 4096, IPC_CREAT | 0664); if (-1 == shmid) { perror("fail to shmget"); return -1; } //3.映射共享内存空间 pshmaddr = shmat(shmid, NULL, 0); if (NULL == pshmaddr) { perror("fail to shmat"); return -1; } //4.从终端接收写入到共享内存中 while (1) { gets(pshmaddr); if (!strcmp(pshmaddr, ".quit")) { break; } } //5.解除映射 ret = shmdt(pshmaddr); if (-1 == ret) { perror("fail to shmdt"); return -1; } return 0; } |
信号灯:
有名信号量数组
1.创建信号灯
int semget(key_t key, int nsems, int semflg);
功能：
创建信号量数组
参数：
key:IPC对象名称
nsems:信号量个数
semflg:信号量属性
IPC_CREAT：创建一个信号量数组
返回值：
成功返回0
失败返回-1
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 | #include "../head.h" int main(void) { //1.创建IPC对象名称 key_t key; int semid = 0; union semun myun; struct sembuf mybuf; int ret = 0; key = ftok("/", 'a'); if (-1 == key) { perror("fail to ftok"); return -1; } //2.创建信号量数组 semid = semget(key, 2, IPC_CREAT | 0664); if (-1 == semid) { perror("fail to semget"); return -1; } //将下标为0的读信号量设置为0 myun.val = 0; ret = semctl(semid, 0, SETVAL, myun); if (-1 == ret) { perror("fail to semctl"); return -1; } //将下标为1的写信号量设置为1 myun.val = 1; ret = semctl(semid, 1, SETVAL, myun); if (-1 == ret) { perror("fail to semctl"); return -1; } //申请写信号量 mybuf.sem_num = 1; mybuf.sem_op = -1; mybuf.sem_flg = SEM_UNDO; ret = semop(semid, &mybuf, 1); if (-1 == ret) { perror("fail to semop"); return -1; } printf("拿到写信号量了!\n"); //释放读信号量 mybuf.sem_num = 0; mybuf.sem_op = +1; mybuf.sem_flg = SEM_UNDO; ret = semop(semid, &mybuf, 1); if (-1 == ret) { perror("fail to semop"); return -1; } printf("释放读信号量了!\n"); //申请读信号量 mybuf.sem_num = 0; mybuf.sem_op = -1; mybuf.sem_flg = SEM_UNDO; ret = semop(semid, &mybuf, 1); if (-1 == ret) { perror("fail to semop"); return -1; } printf("申请读信号量了!\n"); //申请读信号量 mybuf.sem_num = 0; mybuf.sem_op = -1; mybuf.sem_flg = SEM_UNDO; ret = semop(semid, &mybuf, 1); if (-1 == ret) { perror("fail to semop"); return -1; } printf("申请读信号量了!\n"); return 0; } |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 | #include "../head.h" /* 对信号量初始化 */ int init_sem(int semid, int *parray, int len) { int i = 0; union semun myun; int ret = 0; for (i = 0; i < len; i++) { myun.val = parray[i]; ret = semctl(semid, i, SETVAL, myun); if (-1 == ret) { return -1; } } return 0; } /* 信号量申请操作 */ int sem_p(int semid, int semnum) { int ret = 0; struct sembuf mybuf; mybuf.sem_num = semnum; mybuf.sem_op = -1; mybuf.sem_flg = SEM_UNDO; ret = semop(semid, &mybuf, 1); if (-1 == ret) { return -1; } return 0; } /* 信号量释放操作 */ int sem_v(int semid, int semnum) { int ret = 0; struct sembuf mybuf; mybuf.sem_num = semnum; mybuf.sem_op = +1; mybuf.sem_flg = SEM_UNDO; ret = semop(semid, &mybuf, 1); if (-1 == ret) { return -1; } return 0; } |
2.向信号灯发送命令
int semctl(int semid, int semnum, int cmd, ...);
功能:
向信号灯发送命令
参数:
IPC_RMID 删除信号灯
SETVAL 设置第semnum-th信号量的值为arg.val
返回值:
成功返回0
失败返回-1
3.对信号量完成申请和释放操作
int semop(int semid, struct sembuf *sops, size_t nsops);
功能：
对信号量完成申请和释放操作
参数：
semid:信号灯ID号
sops:信号灯操作数组
unsigned short sem_num; //操作信号量的下标
short sem_op; //对信号量的操作 +1(释放信号量) -1(申请信号量)
short sem_flg; //SEM_UNDO 操作结束后,信号量的值会恢复到原来的值
nsops:数组元素个数
返回值：
成功返回0
失败返回-1
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 | #include "../head.h" /* 对信号量初始化 */ int init_sem(int semid, int *parray, int len) { int i = 0; union semun myun; int ret = 0; for (i = 0; i < len; i++) { myun.val = parray[i]; ret = semctl(semid, i, SETVAL, myun); if (-1 == ret) { return -1; } } return 0; } /* 信号量申请操作 */ int sem_p(int semid, int semnum) { int ret = 0; struct sembuf mybuf; mybuf.sem_num = semnum; mybuf.sem_op = -1; mybuf.sem_flg = SEM_UNDO; ret = semop(semid, &mybuf, 1); if (-1 == ret) { return -1; } return 0; } /* 信号量释放操作 */ int sem_v(int semid, int semnum) { int ret = 0; struct sembuf mybuf; mybuf.sem_num = semnum; mybuf.sem_op = +1; mybuf.sem_flg = SEM_UNDO; ret = semop(semid, &mybuf, 1); if (-1 == ret) { return -1; } return 0; } |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | #include "../head.h" int main(void) { //1.创建 key 值 key_t key; int semid = 0; int shmid = 0; int val[2] = {0, 1}; char *pshmaddr = NULL; key = ftok("/", 'a'); if (-1 == key) { perror("fail to ftok"); return -1; } //2.创建共享内存 shmid = shmget(key, 4096, IPC_CREAT | 0664); if (-1 == shmid) { perror("fail to shmget"); return -1; } //3.创建信号量数组 semid = semget(key, 2, IPC_CREAT | 0664); if (-1 == semid) { perror("fail to semget"); return -1; } //4.对信号量数组初始化 init_sem(semid, val, 2); //5.映射共享内存 pshmaddr = shmat(shmid, NULL, 0); if (NULL == pshmaddr) { perror("fail to shmat"); return -1; } while (1) { //6.申请读资源 sem_p(semid, 0); //7.读操作 printf("内容:%s\n", pshmaddr); if (!strcmp(pshmaddr, ".quit")) { break; } //8.释放写资源 sem_v(semid, 1); } shmdt(pshmaddr); shmctl(shmid, IPC_RMID, NULL); semctl(semid, 0, IPC_RMID); return 0; } |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 | #include "../head.h" int main(void) { //1.创建 key 值 key_t key; int semid = 0; int shmid = 0; int val[2] = {0, 1}; char *pshmaddr = NULL; key = ftok("/", 'a'); if (-1 == key) { perror("fail to ftok"); return -1; } //2.创建共享内存 shmid = shmget(key, 4096, IPC_CREAT | 0664); if (-1 == shmid) { perror("fail to shmget"); return -1; } //3.创建信号量数组 semid = semget(key, 2, IPC_CREAT | 0664); if (-1 == semid) { perror("fail to semget"); return -1; } //4.对信号量数组初始化 init_sem(semid, val, 2); //5.映射共享内存 pshmaddr = shmat(shmid, NULL, 0); if (NULL == pshmaddr) { perror("fail to shmat"); return -1; } while (1) { //6.申请写资源 sem_p(semid, 1); //7.写操作 gets(pshmaddr); //8.释放读资源 sem_v(semid, 0); if (!strcmp(pshmaddr, ".quit")) { break; } } shmdt(pshmaddr); return 0; } |
扫一扫
662
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
