Linux进程通信的试验

最新推荐文章于 2023-06-25 17:34:57 发布
最新推荐文章于 2023-06-25 17:34:57 发布
阅读量1.2k 收藏 12
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44931542/article/details/106202358
版权

1、实验目的

1.1了解Linux进程通信的概念。
1.2 掌握Linux进程通信的常用方法。

2、实验内容

创建admin用户，密码也是admin。
用admin登陆后，创建src目录，所有的源代码、中间代码和目标代码都放在/home/admin/src目录下。
（1）编写一个程序创建子进程，子进程循环打印一行提示文字，父进程等待10秒钟后向子进程发送SIGKILL信号，杀死子进程。

#include<stdio.h>
#include<sys/types.h>
#include<signal.h>
#include<unistd.h>
#include<stdlib.h>

int  main()
{
	pid_t result;
	int ret;
	result=fork();
	if(result<0)
	{
		perror("create fault!");
		exit(1);
	}
	else if(result==0)
	{
		while(1)
		{
			printf("this is son process PID:%d\n",getpid());
		}
	}
	else
	{
		sleep(10);
		if(ret=kill(result,SIGKILL)==0)
		{
			printf("\nthis is father process PID %d\n",getpid());
		}
		else
		{
			perror("function kill ERROR !");		
		}
	}
return 0;

}

结果：
在这里插入图片描述
（2）编写一个程序创建子进程，父子进程之间通过低级管道通信，父进程循环向子进程发送一个整数，子进程把整数加1后在发送给父进程。

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<string.h>
#include<sys/wait.h>
int main()
{
	pid_t result;
	int num[1]={10};
	int pipe1[2],pipe2[2];
	int buf1[1],buf2[1];
	int i;
	memset(buf1,0,sizeof(buf1));
	memset(buf2,0,sizeof(buf2));
	if(pipe(pipe1)<0)
	{
		printf("create pipe 1 ERROR !");
		//return -1;
	}
	if(pipe(pipe2)<0)
	{
		printf("create pipe 2 ERROR !");
	}
	result=fork();
	if(result<0)
	{
		perror("create son process ERROR !");
	}
	else if(result==0)
	{
		close(pipe1[1]);
		close(pipe2[0]);
		if(read(pipe1[0],buf1,1)>0)
		{
			printf("son process read num: %d\n",buf1[0]);
		}
			
		close(pipe1[0]);
		for( i=0;i<1;i++)
		{
			num[i]++;	
		}
		if(write(pipe2[1],num,1)!=-1)
		{
			printf("son process add 1,num: %d\n",num[0]);
		}
		close(pipe2[1]);
		waitpid(result,NULL,0);
		exit(0);
	}
	else
	{
		close(pipe1[0]);
		close(pipe2[1]);
		if(write(pipe1[1],num,1)!=-1)
		{
			printf("father process write num: %d\n",num[0]);
		}
		close(pipe1[1]);
		waitpid(result,NULL,0);
		//sleep(10);
		if(read(pipe2[0],buf2,1)>0)
		{
			printf("father process read num: %d\n",buf2[0]);
		}
		close(pipe2[0]);
		exit(0);
	}
return 0;
}

结果：
在这里插入图片描述
（3）编写两个程序，通过命令管道实现两个进程之间的聊天通信，两个进程循环通过键盘接受输入的信息并发送给对方。
张三端：

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<string.h>
#include<fcntl.h>
#include<unistd.h>

int main()
{
	int i,rfd,wfd,len=0,fd_in;
	char str[32];
	int flag,stdinflag;
	fd_set write_fd,read_fd;
	struct timeval net_timer;
	mkfifo("fifo1",S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH);
	mkfifo("fifo2",S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH);
	wfd=open("fifo1",O_WRONLY);
	rfd=open("fifo2",O_RDONLY);
	if(rfd<=0||wfd<=0)
		return 0;
	printf("this is zhangsan !\n");
	while(1)
	{
		FD_ZERO(&read_fd);
		FD_SET(rfd,&read_fd);
		FD_SET(fileno(stdin),&read_fd);
		net_timer.tv_sec=5;
		net_timer.tv_usec=0;
		memset(str,0,sizeof(str));
		if(i=select(rfd+1,&read_fd,NULL,NULL,&net_timer)<0)
			continue;
		if(FD_ISSET(rfd,&read_fd))
		{
			read(rfd,str,sizeof(str));
			printf("lisi: %s\n",str);		
		}
		if(FD_ISSET(fileno(stdin),&read_fd))
		{
			fgets(str,sizeof(str),stdin);
			len=write(wfd,str,strlen(str));
		}
	}
	close(rfd);
	close(wfd);
}

李四端：

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<string.h>
#include<fcntl.h>
#include<unistd.h>

int main()
{
	int i,rfd,wfd,len=0,fd_in;
	char str[32];
	int flag,stdinflag;
	fd_set write_fd,read_fd;
	struct timeval net_timer;
	mkfifo("fifo1",S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH);
	mkfifo("fifo2",S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH);
	rfd=open("fifo1",O_RDONLY);
	wfd=open("fifo2",O_WRONLY);
	if(rfd<=0||wfd<=0)
		return 0;
	printf("this is lisi !\n");
	while(1)
	{
		FD_ZERO(&read_fd);
		FD_SET(rfd,&read_fd);
		FD_SET(fileno(stdin),&read_fd);
		net_timer.tv_sec=5;
		net_timer.tv_usec=0;
		memset(str,0,sizeof(str));
		if(i=select(rfd+1,&read_fd,NULL,NULL,&net_timer)<0)
			continue;
		if(FD_ISSET(rfd,&read_fd))
		{
			read(rfd,str,sizeof(str));
			printf("zhangsan: %s\n",str);		
		}
		if(FD_ISSET(fileno(stdin),&read_fd))
		{
			fgets(str,sizeof(str),stdin);
			len=write(wfd,str,strlen(str));
		}
	}
	close(rfd);
	close(wfd);
}

结果：
在这里插入图片描述
（4）编写两个程序，通过消息队列实现两个进程之间的聊天通信，两个进程循环通过键盘接受输入的信息并发送给对方。
张三端：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#define IPC_KEY 0x12345678 

#define TYPE_S 1
#define TYPE_C 2
struct msgbuf {
    long mtype;      
    char mtext[4028];   
};

int main()
{
    int msgid=-1;
     msgid=msgget(IPC_KEY,IPC_CREAT | 0664);
    if(msgid<0){
        perror("msgget error");
        return -1;
    }
    printf("this is zhangsan:\n");
    while(1){
	    struct msgbuf buf;
	    memset(&buf,0x00,sizeof(struct msgbuf));
	    buf.mtype=TYPE_C;
	    scanf("%s\n",buf.mtext);
	    msgsnd(msgid,&buf,4028,0);
	    
	    msgrcv(msgid,&buf,4028,TYPE_S,0);
	    printf("lisi:%s\n",buf.mtext);
    }
    msgctl(msgid,IPC_RMID,NULL);
    return 0;
}

李四端：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#define IPC_KEY 0x12345678 
#define TYPE_S 1
#define TYPE_C 2
struct msgbuf {
    long mtype;       
    char mtext[4028];    
};

int main()
{
    int msgid=-1;
      
    msgid=msgget(IPC_KEY,IPC_CREAT | 0664);
    if(msgid<0){
        perror("msgget error");
        return -1;
    }
    printf("this is lisi:\n");
    while(1){
    
	struct msgbuf buf;
    	msgrcv(msgid,&buf,4028,TYPE_C,0);
    	printf("zhangsan:%s\n",buf.mtext);
   	 memset(&buf,0x00,sizeof(struct msgbuf));
    	buf.mtype=TYPE_S;
    	scanf("%s\n",buf.mtext);
    	msgsnd(msgid,&buf,4028,0);
    }
    msgctl(msgid,IPC_RMID,NULL);       
    return 0;
}

在这里插入图片描述
（5）编写两个程序，通过共享内存实现两个进程之间的数据传递，数据是一个关于学生信息的结构体，结构体成员变量包括姓名（字符串），年龄（整数），成绩（float类型数组，包含10个元素）。

写操作：

#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<unistd.h>
#include<string.h>
#define key 0x1234

typedef struct
{
 char name[4];
 int age;
 float grade[10];
} student;

int main()
{
 int shm_id;
 int i,j;
 char temp;
 student *p_map;
 shm_id=shmget(key,4096,IPC_CREAT);
 if(shm_id==-1)
 {
  perror("get id ERROR !");
  return -1;
 }
 p_map=(student*)shmat(shm_id,NULL,0);
 temp='a';
 for(i=0;i<10;i++)
 {
  temp+=1;
  memcpy((*(p_map+i)).name,&temp,1);
  (*(p_map+i)).age=20+i;
  for(j=0;j<10;j++)
  {
   (*(p_map+i)).grade[j]=90+j;
  }
 }
 if(shmdt(p_map)==-1)
  perror("ERROR!");
}

读操作：

#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<unistd.h>
#include<string.h>
#define key 0x1234

typedef struct
{
 char name[4];
 int age;
 float grade[10];
} sudent;

int main()
{
 int shm_id;
 int i,j;
 char temp;
 sudent *p_map;
 shm_id=shmget(key,4096,IPC_CREAT);
 if(shm_id==-1)
 {
  perror("get id ERROR !");
  return -1;
 }
 p_map=(sudent*)shmat(shm_id,NULL,0);
 for(i=0;i<10;i++)
 {
  printf("name:%s\t",(*(p_map+i)).name);
  printf("age:%d\t",(*(p_map+i)).age);
  printf("grade:\n");
  for(j=0;j<10;j++)
  {
   printf("%f\n",(*(p_map+i)).grade[j]);
  }
  printf("\n");
 }
 if(shmdt(p_map)==-1)
  perror("ERROR!");
}
·............
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux进程间通信-fifo测试
guyingping的博客
05-18 463
1：fifo原因有名管道文件：安全性，不自动化，数据不完整没有保障；锁的机制PHP开发网站的时候，登录，session2：测试mkfifo \\192.168.0.155\ncc\fifo_write.c \\192.168.0.155\ncc\fifo_read.c其中：fifo_write.c#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #i...
Linux进程间通信
注意路标
07-21 167
引言 进程间除了可以使用 fork和exec传送打开的文件，也可以使用IPC（Inter Processing Communication）的方式通信。 经典的IPC包括：管道、FIFO、消息队列、信号量、以及共享存储。 在新的程序中要尽可能的避免使用消息队列和信号量，应该考虑全双工管道和记录锁，他们使用会更加的简单。共享存储依然有它的用途，虽然使用mmap函数也能提供同样的功能。 管道 管...
Nginx极客时间：使用信号管理Nginx的父子进程
ArtAndLife的博客
02-19 482
使用信号管理Nginx的父子进程： Nginx多进程之间进行通信可以使用 共享内存、信号 等方式，当做进程间的管理时，通常只使用 信号 的方式。 Nginx中存在的信号主要有以下几种： 其中，蓝色部分的信号是可以通过Nginx命令行 -s 加特定命令发出的，红色部分的信号只能通过 kill 命令加信号的方式直接发出。 1. Master进程处理的信号： CHLD 信号： Master进程管理Worker进程的主要方式就是通过监听CHLD信号。 Linux操作系统规定，当子进程退出时，会向父进程发送CH
linux 父进程被杀的信号,Linux 父进程发送信号杀死子进程
zz460833359的博客
10-26 256
#include #include #include #include #include void handler(int arg) { printf("receive SIGCHLD\n"); } int main(int argc, const char *argv[]) { signal(SIGCHLD,handler); //注册信号回调函数，当信号发生会调用handler pid_t pid; pid = fork(); if(pid < 0) { perro
linux之父子进程交替打印数字
发如雪
08-22 1646
代码： #include <unistd.h> #include <signal.h> #include <stdio.h> #include <stdlib.h> //本程序：让父子进程交替打印数字,也是icp通信的一种 int n=0,flag=0; void sys_err(char * str){ perror(str); exit(1); } //子进程信号处理函数 void do_sig_child(int num){ printf
进程间的通信
羊山码农的博客
02-28 1398
1进程间的通信         每个进程都有自己的地址空间，进程之间不能直接访问彼此，因此，进程之间的通信需要一个媒介，它就是内核，在内核开辟出一块缓冲区，P1进程把数据从用户空间拷贝到内核缓冲区，P2进程再把数据从内核缓冲区中读走。内核提供的这种机制称为进程间的通信。能够实现进程间的通信的方法有：信号（signal）、管道（pipe）、套接字（socket）和System V IPC机制。
day 4
aencounter的博客
03-16 316
复习： IO操作：打开-读写-关闭 文件操作 文件IO:open -read- write-close-perror-lseek —fd 标准IO:fopen(r w a)-fclose-fgets-fread-fwrite-fputs-!feof(fp) —FILE * fgetc-fseek-rewind-fputc-ftell 目录操作 新知识： 一、目录IO 1. #include <sys/types.h> #include <dirent.h> DIR *o
实验四：Linux下进程管道通信.docx
04-13
**实验四：Linux下进程管道通信** 实验的目标是理解和掌握Linux操作系统中进程间通信的管道机制，通过系统调用pipe()实现数据交换。管道是一种特殊类型的文件，它允许相关进程之间进行单向通信。在这个实验中，我们...
实验 Linux进程通信的参考答案
07-05
实验 Linux 进程通信的参考答案 Linux 进程通信是指在操作系统中，多个进程之间进行数据交换和同步的机制。在 Linux 中，进程通信可以通过信号、管道和共享内存等方式实现。 一、信号机制 在 Linux 中，信号是一...
进程实验_Linux系统进程实验_
09-30
4. **进程通信**： 进程间通信（IPC）是多个进程共享数据或交换信息的方式，包括管道、信号量、消息队列、共享内存等。这些通信机制在"Linux系统编程实验五：进程编程.doc"中可能会有详细讨论。 5. **exec系列函数...
基于linux的进程通信设计方案
01-19
linux下的进程通信手段基本上是从Unix平台上的进程通信手段继承而来的。而对Unix发展做出重大贡献的两大主力AT&T的贝尔实验室及BSD（加州大学伯克利分校的伯克利软件发布中心）在进程间通信方面的侧重点有所不同。...
Linux进程间通信——使用流套接字
09-15
【Linux进程间通信——使用流套接字】这篇文章主要介绍了如何利用socket进行进程间通信，尤其是跨网络的通信。Socket，又称套接字，是一种通信机制，它允许不同计算机或同一计算机上的进程通过网络进行通信。以下是...
Linux编程基础之进程实验练习
后羿的和平鸽
08-18 2293
·进程实验练习一 编写程序创建一个子进程，父进程打印“parent process”字样和自己的pid；子进程打印“child process”字样以及自己的pid和ppid，并通过exec更改代码段，执行cat命令，cat命令中的参数文件为自己的源程序文件。运行结果截图。注意：运行结果中子进程的ppid是否是父进程的pid？若不是，原因是什么，如何修改程序让两者相同？ 答：出现过子进程的ppid≠pid，原因是父进程先于子进程结束。若使两者相同，需要在代码末尾加上“wait(NULL)”，这样就可以让父进
1.编写一个程序创建一个父进程和9个子进程,子进程中打印自己的PID和父进程的PID 父进程打印自己的PID和9个子进程的PID
weixin_47207870的博客
12-29 589
C语言
Linux进程与守护进程的编写试验
maybe__maybe的博客
04-20 518
（1） 编写一个程序创建一个子进程，父进程随后挂起，子进程循环打印自己的进程号和父进程号，并对比ps查询到的进程号。 #include <stdio.h> #include <sys/types.h> #include <unistd.h> int main(int argc, char argv[]) { pid_t pid; int a=1; int i; ...
操作系统——Linux 进程间通信
CSH__的博客
06-25 927
操作系统课设：实验三
【Linux】实验四 进程信号通信
m0_55251293的博客
01-01 2509
1、了解什么是信号 2、了解和熟悉 LINUX 支持的信号量机制 3、熟悉 LINUX 系统中进程之间软中断通信的基本原理
Linux第二次试验：Linux下的进程通信实验
sjx3161的博客
12-28 3336
Linux第二次试验：Linux下的进程通信实验前言一、实验目的二、实验工具与设备三、实验预备知识三、实验内容和步骤五、实验代码及步骤截图六、实验总结 前言 为了帮助同学们完成痛苦的实验课程设计，本作者将其作出的实验结果及代码贴至CSDN中，供同学们学习参考。如有不足或描述不完善之处，敬请各位指出，欢迎各位的斧正！ 一、实验目的 理解Linux的进程间通信机制。 掌握和使用消息队列实现进程间通信。 掌握和使用共享主存实现进程间通信。 掌握何使用信号量实现进程同步。 二、实验工具与设备 装有Linux系统
四台服务器分别部署组件内容.md
最新发布
07-24
四台服务器分别部署组件内容.md
Linux进程通信实验
06-20
进行Linux进程通信实验，你可能会涉及创建这些通信机制的实例，学习它们的使用方法、同步策略以及如何处理可能出现的问题。实验通常会包含编写客户端和服务器程序，演示数据的发送、接收和处理过程。相关问题可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值