实验八 进程间通信

huanlingege

实验八 进程间通信

项目 内容
这个作业属于哪个课程 课程链接
这个作业的要求在哪里 作业要求链接
学号-姓名 17043112-胡安林
作业学习目标 了解进程间通信的常用方式； 掌握管道、消息队列、信号量、共享内存实现进程间通信的方法。

1.举例说明使用匿名管道进行进程通信

父进程 fork 出一个子进程，通过无名管道向子进程发送字符，子进程收到数据后将字符串中的 小写字 符转换成大写并输出。

编写文件 vim hellopipe.c

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
void child(int *fd) {
close(fd[1]); // 子进程关闭写端
char buf[64];
int n = 0,i;
while(1) {
n = read(fd[0], buf, 64);//如果没有数据可读,read会阻塞；如果父进程退出， read 返回 0.
for (i = 0; i < n; ++i)
putchar(toupper(buf[i]));
if (*buf == \'q\') {
close(fd[0]);
exit(0);
}
if (n == 0) {
puts("no data to read!");
sleep(1);
}
}
exit(0);
}
int main() {
int fd[2];//作为传出参数
int n = 0;
char buf[64] = { 0 };
if (pipe(fd) < 0) {

 perror("pipe");
 return -1;
 }
 pid_t pid = fork();
 if (pid == 0) {
 child(fd);
 }
 close(fd[0]);// 父进程关闭读端
 while (1) {
 n = read(STDIN_FILENO, buf, 64);
 write(fd[1], buf, n);
 if (*buf == \'q\') {
 close(fd[1]);
 exit(0);
 }
 }
 return 0;
 }

编译运行 ./hellopipe
父进程从键盘读取数据写到管道中
子进程从管道读取数据并把字母转换成大写输入到管道中

2.举例说明使用 mkfifo 命令创建命名管道以及简单演示管道如何工作

查看文件属性 当使用 mkfifo 创建 hello 文件后，查看文件信息如下：

使用 cat 命令打印 hello 文件内容：

接下来你的 cat 命令被阻塞住
开启另一个终端，执行

然后你会看到被阻塞的 cat 又继续执行完毕，在屏幕打印 “hello world” 。如果你反过来执行上面 两个 命令，会发现先执行的那个总是被阻塞

3.编写两个程序使用第2题中创建的管道进行通信 。

// pipe_send.c
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
int main() {
char buf[64];
int n = 0;
int fd = open("hello", O_WRONLY);
if (fd < 0) {
perror("open fifo");
return -1;
}
puts("has opend fifo");

    while((n = read(STDIN_FILENO, buf, 64)) > 0) {
    write(fd, buf, n);
    if (buf[0] == \'q\')
    break;
    }
    close(fd);
    return 0;
    }

// pipe_recv.c
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>

int main() {
char buf[64];
int n = 0;
int fd = open("hello", O_RDONLY);
if (fd < 0) {
perror("open fifo");
return -1;
}
puts("has opened fifo");

    while((n = read(fd, buf, 64)) > 0) {
    write(STDOUT_FILENO, buf, n);
    }
    if (n == 0) {
    puts("remote closed");
    }
    else {
    perror("read fifo");
    return -1;
    }
    close(fd);
    return 0;
    }

分别开启两个终端，分别运行 pipe_send 和 pipe_recv :

现在两个终端都处于阻塞状态，我们在运行 pipe_send 的终端输入数据，然后我们就可以在运行 pipe_recv 的终端看到相应的输出：

4.编写两个程序分别通过指定的键值创建 IPC 内核对象，以及获取该指定键值的 IPC 内核对象

// ipccreate.c
#include<unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/msg.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char* argv[]) {
if (argc < 3) {
printf("%s <ipc type> <key>\n", argv[0]);
 return -1;
 }
 key_t key = strtoll(argv[2], NULL, 16);//key
 char type = argv[1][0];//
 char buf[64];
 int id;
 if (type == \'0\') {//创建共享内存
 id = shmget(key, getpagesize(), IPC_CREAT | IPC_EXCL | 0644);
 strcpy(buf, "share memory");
 }
 else if (type == \'1\') {//创建消息队列
 id = msgget(key, IPC_CREAT | IPC_EXCL | 0644);
 strcpy(buf, "message queue");
 }
 else if (type == \'2\') {//创建信号量
 id = semget(key, 5, IPC_CREAT | IPC_EXCL | 0644);
 strcpy(buf, "semaphore");
 }
 else {
 printf("type must be 0, 1, or 2\n");
 return -1;
 }
 if (id < 0) {
 perror("get error");
 return -1;
 }
 printf("create %s at 0x%x, id = %d\n", buf, key, id);
 return 0;
 }

编译程序代码结果如下：

5.编写一个程序可以用来创建、删除内核对象，也可以挂接、卸载共享内存，还可以打印、设置内核 对象信息。

// shmctl.c
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#define ASSERT(res)
if((res)<0){perror(__FUNCTION__);exit(-1);}
// 打印
ipc_perm
void printPerm(struct ipc_perm *perm) {
printf("euid of owner = %d\n", perm->uid);
printf("egid of owner = %d\n", perm->gid);
printf("euid of creator = %d\n", perm->cuid);
printf("egid of creator = %d\n", perm->cgid);
printf("mode = 0%o\n", perm->mode);
}
// 打印 ipc 内核对象信息
void printShmid(struct shmid_ds *shmid) {
printPerm(&shmid->shm_perm);
printf("segment size = %ld\n", shmid->shm_segsz);
printf("last attach time = %s", ctime(&shmid->shm_atime));
printf("last detach time = %s", ctime(&shmid->shm_dtime));
printf("last change time = %s", ctime(&shmid->shm_ctime));
printf("pid of creator = %d\n", shmid->shm_cpid);
printf("pid of last shmat/shmdt = %d\n", shmid->shm_lpid);
printf("No. of current attaches = %ld\n", shmid->shm_nattch);
}
// 创建 ipc 内核对象
void create() {
int id = shmget(0x8888, 123, IPC_CREAT | IPC_EXCL | 0664);
printf("create %d\n", id);
ASSERT(id);
}
// IPC_STAT 命令使用，用来获取 ipc 内核对象信息
void show() {
int id = shmget(0x8888, 0, 0);
ASSERT(id);
struct shmid_ds shmid;
ASSERT(shmctl(id, IPC_STAT, &shmid));
printShmid(&shmid);
}
// IPC_SET 命令使用，用来设置 ipc 内核对象信息
void set() {
int id = shmget(0x8888, 123, IPC_CREAT | 0664);
ASSERT(id);
struct shmid_ds shmid;
ASSERT(shmctl(id, IPC_STAT, &shmid));
shmid.shm_perm.mode = 0600;
ASSERT(shmctl(id, IPC_SET, &shmid));
printf("set %d\n", id);
}
// IPC_RMID 命令使用，用来删除 ipc 内核对象
void rm() {
int id = shmget(0x8888, 123, IPC_CREAT | 0664);
ASSERT(id);
ASSERT(shmctl(id, IPC_RMID, NULL));
printf("remove %d\n", id);
}
// 挂接和卸载
void at_dt() {
int id = shmget(0x8888, 123, IPC_CREAT | 0664);
ASSERT(id);    char *buf = shmat(id, NULL, 0);
if (buf == (char*)-1) ASSERT(-1);
printf("shmat %p\n", buf);
sleep(5);// 等待 5 秒后，执行 shmdt
ASSERT(shmdt(buf));
printf("shmdt %p\n", buf);
}
int main(int argc, char *argv[]) {
if (argc < 2) {
printf("usage: %s <option -c -v -s -d -a>\n", argv[0]);
return -1;
}
printf("I\'m %d\n", getpid());
if (!strcmp(argv[1], "-c")) {
create();
}
else if (!strcmp(argv[1], "-v")) {
show();
}
else if (!strcmp(argv[1], "-s")) {
set();
}
else if (!strcmp(argv[1], "-d")) {
rm();
}
else if (!strcmp(argv[1], "-a")) {
at_dt();
}
return 0;
}

编译代码结果如下：

先在另一个终端执行 ./shmctl -a ，然后在当前终端执行 ./shmctl -v ，最后在./shmtcl -a 运行结束后执 行./shmtcl -v

6.编写两程序分别用于向消息队列发送数据和接收数据。 msg_send 程序定义了一个结构体 Msg ， 消息正文部分是结构体 Person 。该程序向消息队列发送了 10 条消息。

// msg_send.c
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#define ASSERT(prompt,res)
if((res)<0){perror(#prompt);exit(-1);}
typedef struct {
char name[20];
int age;
}
Person;
typedef struct {
long type;
Person person;
}Msg;

int main(int argc, char *argv) {
int id = msgget(0x8888, IPC_CREAT | 0664);
ASSERT(msgget, id);
Msg msg[10] = {
{1, {"Luffy", 17}},
{1, {"Zoro", 19}},
{2, {"Nami", 18}},
{2, {"Usopo", 17}},
{1, {"Sanji", 19}},
{3, {"Chopper", 15}},
{4, {"Robin", 28}},
{4, {"Franky", 34}},
{5, {"Brook", 88}},
{6, {"Sunny", 2}}
};
 int i;
 for (i = 0; i < 10; ++i) {
 int res = msgsnd(id, &msg[i], sizeof(Person), 0);
 ASSERT(msgsnd, res);
 }
 return 0;
 }

// msg_recv.c
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#define ASSERT(prompt,res)
if((res)<0){perror(#prompt);exit(-1);}
typedef struct {
char name[20];
    int age;
    }Person;
    typedef struct {
    long type;
    Person person;
    }Msg;
    void printMsg(Msg *msg) {
    printf("{ type = %ld, name = %s, age = %d }\n",
    msg->type, msg->person.name, msg->person.age);
    }
    int main(int argc, char *argv[]) {
    if (argc < 2) {
    printf("usage: %s <type>\n", argv[0]);
    return -1;
    }
    // 要获取的消息类型
    long type = atol(argv[1]);
    // 获取 ipc 内核对象 id
    int id = msgget(0x8888, 0);
    // 如果错误就退出
    ASSERT(msgget, id);
    Msg msg;
    int res;
    while(1) {
    // 以非阻塞的方式接收类型为 type 的消息
    res = msgrcv(id, &msg, sizeof(Person), type, IPC_NOWAIT);
    if (res < 0) {
    // 如果消息接收完毕就退出，否则报错并退出
    if (errno == ENOMSG) {
    printf("No message!\n");
    break;
    }
    else {
    ASSERT(msgrcv, res);
    }
    }
    // 打印消息内容
    printMsg(&msg);
    }
    return 0;
    }

先运行 ./msg_send ，再运行 ./msg_recv 。 接收所有消息:

接收类型为 4 的消息,这时要重新运行 ./msg_send :

接收类型小于等于 3 的所有消息,这是不用再运行 ./msg_send :

7.编写程序举例说明信号量如何操作。

// semop.c
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>

#define R0 0
#define R1 1
#define R2 2

void printSem(int id) {
unsigned short vals[3] = { 0 };
semctl(id, 3, GETALL, vals);
printf("R0 = %d, R1= %d, R2 = %d\n\n", vals[0], vals[1], vals[2]);
}

int main() {
int id = semget(0x8888, 3, IPC_CREAT | IPC_EXCL | 0664);
// 打印信号量值
  puts("信号量初始值（默认值）");
  printSem(id);
  
// 1. 设置第 2 个信号量值
  puts("1. 设置第 2 个信号量(R2)值为 20");
  semctl(id, 2, SETVAL, 20);
  printSem(id);
  
// 2. 同时设置 3 个信号量的值
  puts("2. 同时设置 3 个信号量的值为 12, 5, 9");
  unsigned short vals[3] = {12, 5, 9};
  semctl(id, 0, SETALL, vals);
  printSem(id);
  
// 3. 请求 2 个 R0 资源
  puts("3. 请求 2 个 R0 资源");
  struct sembuf op1 = {0, -2, 0};
  semop(id, &op1, 1);
  printSem(id);

// 4. 请求 3 个 R1 和 5 个 R2
  puts("4. 请求 3 个 R1 和 5 个 R2");
  struct sembuf ops1[2] = {
  {1, -3, 0},
  {2, -5, 0}
  };
  semop(id, ops1, 2);
  printSem(id);
  
// 5. 释放 2 个 R1
  puts("5. 释放 2 个 R1");
  struct sembuf op2 = {1, 2, 0};
  semop(id, &op2, 1);
  printSem(id);
  
// 6. 释放 1 个 R0, 1 个 R1，3 个 R2
  puts("6. 释放 1 个 R0, 1 个 R1，3 个 R2");
  struct sembuf ops2[3] = {
  {0, 1, 0},
  {1, 1, 0},
  {2, 3, 0}
  };
  semop(id, ops2, 3);
  printSem(id);
  
// 7. 删除 ipc 内核对象
  puts("7. 删除 ipc 内核对象");
  semctl(id, 0, IPC_RMID);
  return 0;
  }

8.编写程序使用信号量实现父子进程之间的同步，防止父子进程抢夺 CPU

#include<stdio.h>
#include<stdlib.h>
#include<sys/ipc.h>
#include<sys/sem.h>

static int semid;

static void sem_set()
{
if(semctl(semid,0,SETVAL,1)==-1)
{
   perror("semctl");
   exit(1);
   }
}
static void sem_p()
{
   struct sembuf op = {0,-1,0};
   if(semop(semid,&op,1) == -1){
   perror("semop");
   exit(1);
   }
}
static void sem_v()
{
   struct sembuf op = {0,1,0};
   if(semop(semid,&op,1) == -1)
{
  perror("semop");
  exit(1);
  }
}
static void sem_del()
{
   if(semctl(semid,0,IPC_RMID) == -1)
   {
   perror("semctl");
   exit(1);
   }
}
int main()
{
int i;
pid_t pid;
char ch = \'C\';
semid = semget((key_t)1000,1,0664|IPC_CREAT);
if(semid == -1)
{
perror("semget");
exit(1);
}
sem_set();
pid = fork();
if(pid == -1)

{
sem_del();
exit(1);
}
else if (pid == 0)
ch = \'Z\';
else
ch = \'C\';
srand((unsigned int)getpid());
for(i=0;i<8;i++)
{
sem_p();
printf("%c",ch);
fflush(stdout);
sleep(rand()%4);
printf("%c",ch);
fflush(stdout);
sleep(1);
sem_v();
}
if(pid > 0)
{
   wait(NULL);
   sem_del();
}
printf("\n");
return 0;
}

编译后结果如下：

分类：

技术点：

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode