04--Linux系统编程-进程间通信

合集下载

操作系统实验04 Linux 多进程编程

操作系统实验04 Linux 多进程编程

《操作系统》实验报告实验序号:实验四实验项目名称:实验04 Linux 多进程编程学号1207022103 姓名陈华荣专业、班网络工程实验地点实1-311 指导教师李桂森实验时间2014.10.26一、实验目的及要求1.通过本实验的学习,使学生掌握Linux多进程编程的基本方法。

2.实验内容:利用Linux多进程实现题目所要求的功能。

3.以学生自主训练为主的开放模式组织教学二、实验设备(环境)及要求PC机三、实验内容与步骤1、编写一个显示“HELLO”的c语言程序,并利用GCC编译,然后运行此程序。

(提示:若没有gcc,需先安装gcc编译程序)指令:Apt-get install updateApt-get install gccCd /home/normaluesrTouch helloworld.cVim helloeorld.c在helloworld里编辑进:#include<stdio.h>Int main(){Printf(“helloworld”);Return 0;}然后用gcc进行编译运行:或者直接2、进程的创建:编制一程序,利用系统调用fork()创建两个子进程。

程序运行时,系统中有一个父进程和两个子进程活动,分别让他们显示“A”、“B”和“C”,分析程序运行结果。

3、用ctrl+alt+F2切换到第二个终端(tty2)并使用另外一个用户登录(可利用第二个实验创建的用户登录),然后使用who命令查看用户登录情况。

用ctrl+alt+F1切换到第二个终端(tty1),修改第二步的程序,在每个进程退出前都加上一个sleep(20)的函数来延缓进程的退出,然后运行此程序,立即切换到tty2,使用ps -a命令查看系统运行的进程,观察程序创建的进程都有哪些?pid是多少?4、进程的管道通信:编制一程序,使用系统调用pipe()建立一管道,两个子进程P1和P2分别向管道各写一句话,父进程则从管道中读取出来并显示在屏幕。

Linux的SOCKET编程详解

Linux的SOCKET编程详解

Linux的SOCKET编程详解1. 网络中进程之间如何通信进程通信的概念最初来源于单机系统。

由于每个进程都在自己的地址范围内运行,为保证两个相互通信的进程之间既互不干扰又协调一致工作,操作系统为进程通信提供了相应设施,如UNIX BSD有:管道(pipe)、命名管道(named pipe)软中断信号(signal)UNIX system V有:消息(message)、共享存储区(shared memory)和信号量(semaphore)等.他们都仅限于用在本机进程之间通信。

网间进程通信要解决的是不同主机进程间的相互通信问题(可把同机进程通信看作是其中的特例)。

为此,首先要解决的是网间进程标识问题。

同一主机上,不同进程可用进程号(process ID)唯一标识。

但在网络环境下,各主机独立分配的进程号不能唯一标识该进程。

例如,主机A赋于某进程号5,在B机中也可以存在5号进程,因此,“5号进程”这句话就没有意义了。

其次,操作系统支持的网络协议众多,不同协议的工作方式不同,地址格式也不同。

因此,网间进程通信还要解决多重协议的识别问题。

其实TCP/IP协议族已经帮我们解决了这个问题,网络层的―ip地址‖可以唯一标识网络中的主机,而传输层的―协议+端口‖可以唯一标识主机中的应用程序(进程)。

这样利用三元组(ip地址,协议,端口)就可以标识网络的进程了,网络中的进程通信就可以利用这个标志与其它进程进行交互。

使用TCP/IP协议的应用程序通常采用应用编程接口:UNIX BSD的套接字(socket)和UNIX System V的TLI(已经被淘汰),来实现网络进程之间的通信。

就目前而言,几乎所有的应用程序都是采用socket,而现在又是网络时代,网络中进程通信是无处不在,这就是我为什么说―一切皆s ocket‖。

TCP/IP(Transmission Control Protocol/Internet Protocol)即传输控制协议/网间协议,是一个工业标准的协议集,它是为广域网(WANs)设计的。

进程间通信的几种方法

进程间通信的几种方法

进程间通信的几种方法进程间通信是计算机系统中一种非常常见的需求,它允许多个进程在不同的地址空间中共享资源,实现信息的共享以及通信。

在计算机系统中,进程间通信的方法会根据使用的网络类型以及网络的连接有所不同。

对于进程间通信的方法,一般可以分为以下几种:(一)共享内存共享内存是一种最简单的进程间通信的方式,也是当今使用最为普遍的进程间通信方法。

在此方法中,多个进程可以访问共享内存区域,这样它们就可以直接在内存中进行通信,而且支持多个进程同时读取和写入内存中的数据,能满足多样化的通信需求,从而提高了系统的效率。

但是,由于这种方法不能实现两个进程之间的“双向”通信,因此它只能适用于一些特定的应用场景,而不能满足一般的进程间通信需求。

(二)消息传递消息传递是进程之间通信的常见方法,它允许两个进程之间进行双向通信,同时还能可靠地传输数据。

在消息传递中,多个进程可以通过将自己的传输内容发送到指定的消息服务器来实现进程间通信。

消息服务器会将这些内容发送到另一个进程,以便双方进行通信。

简单的消息传递本质上是一种客户端/服务器架构,而处理多个进程之间的通信时,可以使用一种名为“发布/订阅”的模型。

在这种模型中,发送者会将消息(即发布)发布到消息服务器上,而接收者(即订阅)可以订阅消息服务器上的那些发布消息。

(三)管道(PIPES)管道是另一种常用的进程间通信模式,它可以实现进程间的双向通信。

在管道模式中,多个进程共享一个双向管道,它们可以在这个双向管道上进行双向通信,也就是说,管道的一端可以用来发送数据,另一端可以用来接收数据。

与消息传递不同,管道不需要使用额外的服务器,因此它可以更快地传输数据,但是它也有很大的局限性,无法跨越网络,仅限于同一台机器上的多个进程之间的通信。

(四)信号量信号量是一种重要的进程间通信机制,它可以用来实现同步和互斥操作,使多个进程都能够按照规定的方式来完成工作,从而实现协作和通信。

信号量原理是通过一个数值来控制多个进程对共享资源的访问,当这个数值为正时,它允许多个进程访问共享资源,当这个数值为0时,它就不允许多个进程访问共享资源。

linux线程间通信方式

linux线程间通信方式

linux线程间通信方式
Linux 线程间通信方式包括以下几种:
1. 管道通信:管道是一种半双工的通信方式,只能用于具有亲缘关系的进程之间的通信,父进程创建管道,在进程间传递数据。

2. 信号通信:信号是一种异步通信方式,在进程之间传递简单的信息。

一个进程向另一个进程发送一个信号,另一个进程收到信号后就可以采取相应的操作。

3. 共享内存通信:共享内存是最快的进程间通信方式,可以将内存区域映射到多个进程的地址空间中,实现进程间数据的共享。

需要注意解决信号量、锁等同步问题。

4. 信号量通信:信号量是一种计数器,用来协调多个进程对共享资源的访问。

多个进程需要对信号量进行操作,以实现对共享资源的访问控制。

5. 消息队列通信:消息队列是一种通过消息传递来进行通信的机制,可以在进程之间传递数据块,通常用于进程间的同步和异步通信。

6. 套接字通信:套接字是基于网络通信的一种进程间通信方式,可用于同一主机上进程间通信,也可以在不同主机之间通信。

套接字是基于 TCP/IP 协议栈实现的,需要在数据传输时注意网络传输和数据结构转换等问题。

以上是 Linux 线程间通信的主要方式,开发者可以根据不同的需求和场景选择合适的方式。

详解linux进程间通信-消息队列

详解linux进程间通信-消息队列

详解linux进程间通信-消息队列前⾔:前⾯讨论了信号、管道的进程间通信⽅式,接下来将讨论消息队列。

⼀、系统V IPC 三种系统V IPC:消息队列、信号量以及共享内存(共享存储器)之间有很多相似之处。

每个内核中的 I P C结构(消息队列、信号量或共享存储段)都⽤⼀个⾮负整数的标识符( i d e n t i f i e r )加以引⽤。

⽆论何时创建I P C结构(调⽤m s g g e t、 s e m g e t或s h m g e t) ,都应指定⼀个关键字(k e y),关键字的数据类型由系统规定为 k e y _ t,通常在头⽂件< s y s / t y p e s . h >中被规定为长整型。

关键字由内核变换成标识符。

以上简单介绍了IPC,对接下来介绍的消息队列、信号量和共享内存有助于理解。

⼆、消息队列 1、简介 消息队列是消息的链接表 ,存放在内核中并由消息队列标识符标识。

我们将称消息队列为“队列”,其标识符为“队列 I D”。

m s g g e t⽤于创建⼀个新队列或打开⼀个现存的队列。

m s g s n d⽤于将新消息添加到队列尾端。

每个消息包含⼀个正长整型类型字段,⼀个⾮负长度以及实际数据字节(对应于长度),所有这些都在将消息添加到队列时,传送给 m s g s n d。

m s g r c v⽤于从队列中取消息。

我们并不⼀定要以先进先出次序取消息,也可以按消息的类型字段取消息。

2、函数介绍ftok函数#include <sys/types.h>#include <sys/ipc.h>key_t ftok(const char *pathname, int proj_id);//“/home/linux” , 'a'功能:⽣成⼀个key(键值)msgget函数#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>int msgget(key_t key, int msgflg);功能:创建或取得⼀个消息队列对象返回:消息队列对象的id 同⼀个key得到同⼀个对象格式:msgget(key,flag|mode);flag:可以是0或者IPC_CREAT(不存在就创建)mode:同⽂件权限⼀样msgsnd函数int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);功能:将msgp消息写⼊标识为msgid的消息队列msgp:struct msgbuf {long mtype; /* message type, must be > 0 */消息的类型必须>0char mtext[1]; /* message data */长度随意};msgsz:要发送的消息的⼤⼩不包括消息的类型占⽤的4个字节msgflg:如果是0 当消息队列为满 msgsnd会阻塞如果是IPC_NOWAIT 当消息队列为满时不阻塞⽴即返回返回值:成功返回id 失败返回-1msgrcv函数ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);功能:从标识符为msgid的消息队列⾥接收⼀个指定类型的消息并存储于msgp中读取后把消息从消息队列中删除msgtyp:为 0 表⽰⽆论什么类型都可以接收msgp:存放消息的结构体msgsz:要接收的消息的⼤⼩不包含消息类型占⽤的4字节msgflg:如果是0 标识如果没有指定类型的消息就⼀直等待如果是IPC_NOWAIT 则表⽰不等待msgctl函数int msgctl(int msqid, int cmd, struct msqid_ds *buf);msgctl(msgid,IPC_RMID,NULL);//删除消息队列对象 程序2-2将简单演⽰消息队列: --- snd.c ---#include "my.h"typedef struct{long type;char name[20];int age;}Msg;int main(){key_t key = ftok("/home/liudw",'6');printf("key:%x\n",key);int msgid = msgget(key,IPC_CREAT|O_WRONLY|0777);if(msgid<0){perror("msgget error!");exit(-1);}Msg m;puts("please input your type name age:");scanf("%ld%s%d",&m.type,,&m.age);msgsnd(msgid,&m,sizeof(m)-sizeof(m.type),0);return0;} --- rcv.c ---#include "my.h"typedef struct{long type;char name[20];int age;}Msg;int main(){key_t key = ftok("/home/liudw",'6');printf("key:%x\n",key);int msgid = msgget(key,O_RDONLY);if(msgid<0){perror("msgget error!");exit(-1);}Msg rcv;long type;puts("please input type you want!");scanf("%ld",&type);msgrcv(msgid,&rcv,sizeof(rcv)-sizeof(type),type,0);printf("rcv--name:%s age:%d\n",,rcv.age);msgctl(msgid,IPC_RMID,NULL);return0;} 运⾏演⽰: 三、详解ftok函数 ftok根据路径名,提取⽂件信息,再根据这些⽂件信息及project ID合成key,该路径可以随便设置。

linux进程间通讯的几种方式的特点和优缺点

linux进程间通讯的几种方式的特点和优缺点

linux进程间通讯的几种方式的特点和优缺点Linux进程间通讯的方式有多种,其优缺点也不尽相同,接受者依赖发送者之时间特性可承载其优端。

下面就讨论几种典型的方式:1、管道(Pipe):是比较传统的方式,管道允许信息在不同进程之间传送,由一端输入,另一端输出,提供全双工式劝劝信息传送,除此之外,伺服端也可以将其服务转换为管道,例如说Web服务程序。

管道的优点:简单易懂、可靠、灵活、容易管理,可以控制发送端和接收端的信息流量。

管道的缺点:线程之间的信息量不能太大,也只能在本机上使用,不能通过网络发送信息。

2、消息队列(Message queue):消息队列主要应用在大型网络中,支持多种消息队列协议,广泛用于在远程机器上的进程间的交互、管理进程间的数据和同步问题。

消息队列的优点:主要优点是这种方式可以将消息发送给接收端,然后接收端可以从距离发送端远的地方网络上接收消息,通过消息队列可以较好的管理和控制进程间的数据流量和同步问题。

消息队列的缺点:缺点是消息队里的管理复杂,并且有一定的延迟,而且它使用时应避免共享内存,对于多处理器和跨网络环境, TCP 传输数据时也比不上消息队列的传输效率高。

3、共享内存(Share Memory):是最高效的进程间通信方式,也是最常用的,它使进程在通信时共享一个存储地址,双方都可以以该存储地址作为参数进行读写操作。

共享内存的优点:实现高性能,数据同步操作快、数据可以高速传输,可以解决多处理器以及跨网络环境的通信。

共享内存的缺点:由于进程间直接使用物理内存,没有任何保护,所需要使用较复杂的同步机制来完成数据的可靠传输。

总的来说,每种进程通讯方式都有各自的优缺点,不同的系统需求也许需要多种方案的相互配合才能有效的处理系统间通信的问题。

系统设计者应根据具体系统需求,选择合适的进程通信方式来实现更好的进程间通信。

操作系统的消息传递和进程间通信实现进程间的信息传递和通信

操作系统的消息传递和进程间通信实现进程间的信息传递和通信

操作系统的消息传递和进程间通信实现进程间的信息传递和通信操作系统是计算机中非常重要的一个组成部分,它负责管理和控制计算机的硬件和软件资源。

在多道程序设计环境下,操作系统需要负责调度和管理多个进程的执行。

而进程间的信息传递和通信是操作系统中一个关键的功能,它使得不同进程之间能够相互交互、传递数据,从而实现协同工作和资源共享。

本文将探讨操作系统中的消息传递和进程间通信,以及它们的实现方法和技术。

一、消息传递在操作系统中,进程间的信息传递可以通过消息传递的方式来实现。

消息传递是指一个进程向另一个进程发送消息,并由接收进程接收和处理该消息。

消息传递可以用于进程间的同步和通信,从而实现进程之间的交互。

消息传递一般包括以下几个步骤:1. 消息的创建:发送进程首先需要创建一条消息,并在消息中填写相应的内容。

消息可以包含数据、指令等信息,以满足不同的需求。

2. 消息的发送:发送进程将创建好的消息发送给接收进程。

发送进程需要指定接收进程的标识符,以确保消息能够被正确地发送到目标进程。

3. 消息的接收:接收进程通过等待操作等待消息的到达。

当消息到达时,接收进程将检查消息的标识符,以确定该消息是否是自己所期望接收的。

4. 消息的处理:接收进程接收到消息后,会对消息进行处理。

处理的方式取决于消息的内容和接收进程的需求。

消息传递可以有两种方式:直接消息传递和间接消息传递。

直接消息传递是指发送进程直接发送消息给接收进程。

间接消息传递是指通过操作系统的消息队列来传递消息。

不同的方式适用于不同的场景和需求。

二、进程间通信的实现为了实现进程间的信息传递和通信,操作系统提供了多种机制和技术。

以下是几种常见的进程间通信的实现方式:1. 共享内存共享内存是一种在多个进程之间共享同一块物理内存的方式。

通过将一块内存区域映射到多个进程的地址空间中,进程可以通过读写共享内存的方式来进行通信。

共享内存的优点是速度快,但需要进程之间进行同步和互斥操作,以避免数据的冲突和错误。

简述linux中进程间各种通信方式特点

简述linux中进程间各种通信方式特点

简述linux中进程间各种通信方式特点Linux中进程间通信方式有多种,包括管道,命名管道,消息队列,信号量,共享内存和套接字。

每种通信方式都有自己的特点和适用场景。

一、管道1. 特点:- 管道是最简单的进程间通信方式之一,只能用于具有父子关系的进程间通信。

- 管道是一个单向通道,数据只能在一个方向上流动。

- 管道的容量有限,在写度满之前,读进程阻塞;在读度空之前,写进程阻塞。

2. 使用场景:- 父子进程之间需要进行简单的数据传输。

二、命名管道1. 特点:- 命名管道是一种特殊类型的文件,可以实现不相关进程的通信。

- 命名管道是半双工的,只能在一个方向上传输数据。

- 命名管道是顺序读写的,进程可以按照顺序读取其中的数据。

2. 使用场景:- 不相关的进程需要进行数据传输。

- 需要按照顺序进行传输的场景。

三、消息队列1. 特点:- 消息队列是一组消息的链表,具有特定的格式和标识符。

- 消息队列独立于发送和接收进程的生命周期,可以实现不相关进程间的通信。

- 消息队列可以根据优先级进行消息的传输。

2. 使用场景:- 需要实现进程间相对复杂的数据传输。

- 数据传输具有优先级。

四、信号量1. 特点:- 信号量是一个计数器,用于实现多个进程之间的互斥和同步。

- 信号量有一个整数值,只能通过定义的操作进行访问。

- 信号量可以用于控制临界区的访问次数。

2. 使用场景:- 多个进程需要共享公共资源。

- 需要进行互斥和同步操作。

五、共享内存1. 特点:- 共享内存是一块可以被多个进程共同访问的内存区域。

- 共享内存是最快的进程间通信方式,因为数据不需要在进程之间拷贝。

- 共享内存需要通过同步机制(如信号量)进行互斥访问。

2. 使用场景:- 需要高效地进行大量数据传输。

- 数据读写频繁,需要最小化数据拷贝的开销。

六、套接字1. 特点:- 套接字是一种网络编程中常用的进程间通信方式。

- 套接字支持不同主机上的进程进行通信。

linux 中的进程处理和控制方式

linux 中的进程处理和控制方式

linux 中的进程处理和控制方式Linux 是一种广泛使用的操作系统,它具有强大的进程处理和控制功能。

在 Linux 系统中,进程是进行任务的基本单位,它们可以同时运行,互相通信,共享资源,因此进程处理和控制是 Linux 系统重要的组成部分。

Linux 提供了多种方式来处理和控制进程。

以下是一些常见的方式:1. 创建新进程:在 Linux 系统中,可以通过 fork() 系统调用创建一个新的子进程。

子进程是通过复制父进程的内存空间、文件描述符和其他资源来创建的。

这样可以实现并行处理任务,提高系统的效率。

创建新进程时,可以使用 exec() 系统调用来加载一个新的程序运行。

2. 进程调度:Linux 使用调度器(scheduler)来决定哪个进程在何时执行。

调度算法会根据进程的优先级(priority)和调度策略来决定进程的执行顺序。

常见的调度策略包括先进先出(FIFO)、最短作业优先(SJF)、轮转(Round Robin)等。

通过合理的调度算法,可以提高系统的响应速度和资源利用率。

3. 进程间通信:在 Linux 中,进程之间可以通过多种方式进行通信。

其中最常用的方式是通过管道(pipe)、信号(signal)和共享内存(shared memory)来进行进程间的数据交换。

管道可以实现进程的单向通信,信号可以用于进程之间的异步通信,而共享内存可以让多个进程共享同一片内存区域,实现高效的数据交换。

4. 进程控制:Linux 提供了多个命令和系统调用来控制进程的行为。

例如,可以使用 ps 命令来查看系统中正在运行的进程,使用kill 命令发送信号终止进程,使用 nice 命令来改变进程的优先级等。

此外,还可以使用进程控制信号(Process Control Signals)来改变进程的状态,如暂停、继续、停止等。

5. 进程管理工具:Linux 提供了一些进程管理工具来帮助用户更方便地处理和控制进程。

如何使用进程间通信在Shell脚本中实现数据共享

如何使用进程间通信在Shell脚本中实现数据共享

如何使用进程间通信在Shell脚本中实现数据共享进程间通信(Inter-process Communication,IPC)是指不同进程之间进行数据交换和共享的机制。

在Shell脚本中,我们可以使用进程间通信来实现数据共享,以便多个进程之间可以互相传递数据并进行协作。

下面将介绍如何使用进程间通信在Shell脚本中实现数据共享。

一、管道(Pipe)管道是一种IPC机制,用于在Shell脚本中将一个进程的输出直接送给另一个进程作为输入。

可以用竖线符号“|”来创建一个管道,将一个命令的输出传递给另一个命令。

下面是一个使用管道在Shell脚本中实现数据共享的例子:```shell#!/bin/bash# 启动进程A并将数据输出到标准输出processA | processB```在这个例子中,进程A的输出会通过管道传递给进程B的标准输入。

这样,进程B就可以读取来自进程A的数据,并进行相应的处理。

二、命名管道(Named Pipe)命名管道是一种特殊的文件,它可以用来实现不同进程之间的通信。

在Shell脚本中,我们可以使用mkfifo命令来创建一个命名管道。

下面是一个使用命名管道在Shell脚本中实现数据共享的例子:```shell#!/bin/bash# 创建一个命名管道mkfifo mypipe# 启动进程A并将数据输出到命名管道processA > mypipe &# 启动进程B并从命名管道读取数据processB < mypipe# 删除命名管道rm mypipe```在这个例子中,进程A将数据输出到命名管道mypipe,而进程B则从命名管道mypipe中读取数据。

这样,进程A和进程B就可以通过命名管道进行数据共享。

三、共享内存(Shared Memory)共享内存是一种进程间通信的方式,它允许不同的进程直接访问同一个内存区域。

在Shell脚本中,我们可以使用shmget、shmat和shmdt等命令来创建和访问共享内存。

Linux进程间通信(七):消息队列msgget()、msgsend()、msgrcv()。。。

Linux进程间通信(七):消息队列msgget()、msgsend()、msgrcv()。。。

Linux进程间通信(七):消息队列msgget()、msgsend()、msgrcv()。

下⾯来说说如何⽤不⽤消息队列来进⾏进程间的通信,消息队列与命名管道有很多相似之处。

有关命名管道的更多内容可以参阅我的另⼀篇⽂章:⼀、什么是消息队列消息队列提供了⼀种从⼀个进程向另⼀个进程发送⼀个数据块的⽅法。

每个数据块都被认为含有⼀个类型,接收进程可以独⽴地接收含有不同类型的数据结构。

我们可以通过发送消息来避免命名管道的同步和阻塞问题。

但是消息队列与命名管道⼀样,每个数据块都有⼀个最⼤长度的限制。

Linux⽤宏MSGMAX和MSGMNB来限制⼀条消息的最⼤长度和⼀个队列的最⼤长度。

⼆、在Linux中使⽤消息队列Linux提供了⼀系列消息队列的函数接⼝来让我们⽅便地使⽤它来实现进程间的通信。

它的⽤法与其他两个System V PIC机制,即信号量和共享内存相似。

1、msgget()函数该函数⽤来创建和访问⼀个消息队列。

它的原型为:int msgget(key_t, key, int msgflg);与其他的IPC机制⼀样,程序必须提供⼀个键来命名某个特定的消息队列。

msgflg是⼀个权限标志,表⽰消息队列的访问权限,它与⽂件的访问权限⼀样。

msgflg可以与IPC_CREAT做或操作,表⽰当key所命名的消息队列不存在时创建⼀个消息队列,如果key所命名的消息队列存在时,IPC_CREAT标志会被忽略,⽽只返回⼀个标识符。

它返回⼀个以key命名的消息队列的标识符(⾮零整数),失败时返回-1.2、msgsnd()函数该函数⽤来把消息添加到消息队列中。

它的原型为:int msgsend(int msgid, const void *msg_ptr, size_t msg_sz, int msgflg);msgid是由msgget函数返回的消息队列标识符。

msg_ptr是⼀个指向准备发送消息的指针,但是消息的数据结构却有⼀定的要求,指针msg_ptr所指向的消息结构⼀定要是以⼀个长整型成员变量开始的结构体,接收函数将⽤这个成员来确定消息的类型。

实验五Linux进程间通信

实验五Linux进程间通信

实验五Linux进程间通信实验五Linux进程间通信姓名学号1.实验⽬的1)熟悉在C语⾔源程序中使⽤Linux所提供的系统调⽤界⾯的⽅法;2)掌握Linux中⼦进程的创建⽅法以及调度执⾏情况,理解进程与程序的区别;3)掌握软中断信号的使⽤,了解使⽤软中断通信实现异步事件的⽅法;4)掌握⽗⼦进程使⽤管道进⾏通信的⽅法,了解管道通信的特点和上的限制。

2.实验内容1)⽗进程创建⼦进程(1)实现⽗进程创建⼀个⼦进程,返回后⽗⼦进程都分别循环输出字符串“I am parent.”或“I am child.”5次,每输出1次后使⽤sleep(1)延时1秒,然后再进⼊下⼀循环。

【编程⽂件如下】【执⾏结果如下】(2)在源程序中连续使⽤4个fork(),⽽不⽤if()进⾏返回值的判断,在4个fork()语⾔后⾯输出字符“A”,观察并分析该程序编译连接执⾏后的输出结果。

【编程⽂件如下】(3)由⽗进程创建⼀个⼦进程,⼦进程的功能史输出26个英⽂字母,使⽤execl()加载⼦进程的程序。

【编程⽂件letters.c如下】【编程⽂件execl.c如下】【运⾏结果如下】2)软中断的使⽤(1)编写⼀个程序循环显⽰“How are you?”,当键盘输⼊Ctrl+C的组合键后中断循环显⽰,执⾏软中断程序,软中断程序的功能是修改循环变量的值终⽌循环,然后输出“Byebye”。

【编程⽂件how.c如下】【运⾏结果如下】3)管道的使⽤:(1)编写⼀个程序,实现:⽗进程使⽤系统调⽤pipe()创建⼀个⽆名管道;(2)创建2个⼦进程,分别向管道各发下⾯中1条信息后结束:Child 1 is sending a message to parent!Child 2 is sending a message to parent!【编程⽂件child12.c如下】【运⾏结果如下】3.实验思考1)如果连续创建多个⼦进程⽽不使⽤条件进⾏各⾃空间的分隔,会出现什么情况?【答】:运⾏结果将会出现16个“A”。

linux进程间通信实验心得

linux进程间通信实验心得

linux进程间通信实验心得随着对Linux系统的深入了解,我对进程间通信(IPC)的重要性有了更深刻的认识。

在这次实验中,我通过实际操作,掌握了多种Linux进程间通信的方法,并对它们的特点和应用场景有了更清晰的了解。

实验过程中,我主要接触了三种主要的进程间通信方法:管道(Pipe)、信号(Signal)和共享内存(Shared Memory)。

每种方法都有其独特的特点和使用场景。

管道是最基本的进程间通信方式,它允许父子进程之间进行通信。

通过管道,一个进程可以将数据写入到管道中,而另一个进程可以从管道中读取数据。

我在实验中创建了多个进程,并通过管道实现了它们之间的数据传递。

虽然管道简单易用,但它的通信能力有限,只能用于父子进程或兄弟进程之间的通信。

信号是一种异步的进程间通信方式,一个进程可以向另一个进程发送信号。

接收进程可以根据信号的类型采取不同的行动。

我在实验中通过信号实现了进程间的控制和同步。

虽然信号可以用于任何两个进程之间的通信,但由于它是异步的,使用起来需要小心处理信号的捕获和处理。

共享内存是一种高效的进程间通信方式,它允许多个进程访问同一块内存空间。

通过共享内存,进程可以快速地读写数据,避免了数据在进程间传递的开销。

我在实验中创建了多个进程,让它们共享一块内存区域,并通过读写共享内存实现了数据的快速传递。

共享内存的优点是通信速度快,但需要处理好同步和互斥问题,以避免数据冲突和错误。

通过这次实验,我对Linux进程间通信有了更深入的了解。

在实际应用中,需要根据具体的需求和场景选择合适的进程间通信方法。

同时,我也认识到进程间通信的复杂性和挑战性,需要仔细考虑和处理各种可能的问题。

在未来的学习和工作中,我将继续深入学习Linux系统及其相关技术,不断提高自己的技能和能力。

同时,我也将关注新技术的发展和应用,保持对行业的敏感度和竞争力。

Linux进程间通信方式之socket使用实例

Linux进程间通信方式之socket使用实例

Linux进程间通信⽅式之socket使⽤实例套接字是⼀种通信机制,凭借这种机制,客户/服务器系统的开发⼯作既可以在本地单机上进⾏,也可以跨⽹络进⾏。

套接字的特性有三个属性确定,它们是:域(domain),类型(type),和协议(protocol)。

套接字还⽤地址作为它的名字。

地址的格式随域(⼜被称为协议族,protocol family)的不同⽽不同。

每个协议族⼜可以使⽤⼀个或多个地址族定义地址格式。

1.套接字的域域指定套接字通信中使⽤的⽹络介质。

最常见的套接字域是AF_INET,它是指Internet⽹络,许多Linux局域⽹使⽤的都是该⽹络,当然,因特⽹⾃⾝⽤的也是它。

其底层的协议——⽹际协议(IP)只有⼀个地址族,它使⽤⼀种特定的⽅式来指定⽹络中的计算机,即IP地址。

在计算机系统内部,端⼝通过分配⼀个唯⼀的16位的整数来表⽰,在系统外部,则需要通过IP地址和端⼝号的组合来确定。

2.套接字类型流套接字(在某些⽅⾯类似域标准的输⼊/输出流)提供的是⼀个有序,可靠,双向字节流的连接。

流套接字由类型SOCK_STREAM指定,它们是在AF_INET域中通过TCP/IP连接实现的。

他们也是AF_UNIX域中常见的套接字类型。

数据包套接字与流套接字相反,由类型SOCK_DGRAM指定的数据包套接字不建⽴和维持⼀个连接。

它对可以发送的数据包的长度有限制。

数据报作为⼀个单独的⽹络消息被传输,它可能会丢失,复制或乱序到达。

数据报套接字实在AF_INET域中通过UDP/IP连接实现,它提供的是⼀种⽆需的不可靠服务。

3.套接字协议只要底层的传输机制允许不⽌⼀个协议来提供要求的套接字类型,我们就可以为套接字选择⼀个特定的协议。

先上⼀个代码服务端://s_unix.c#include <stdio.h>#include <sys/types.h>#include <sys/socket.h>#include <sys/un.h>#define UNIX_DOMAIN "/tmp/UNIX.domain"int main(void){socklen_t clt_addr_len;int listen_fd;int com_fd;int ret;int i;static char recv_buf[1024];int len;struct sockaddr_un clt_addr;struct sockaddr_un srv_addr;listen_fd=socket(PF_UNIX,SOCK_STREAM,0);if(listen_fd<0){perror("cannot create communication socket");return 1;}//set server addr_paramsrv_addr.sun_family=AF_UNIX;strncpy(srv_addr.sun_path,UNIX_DOMAIN,sizeof(srv_addr.sun_path)-1);unlink(UNIX_DOMAIN);//bind sockfd & addrret=bind(listen_fd,(struct sockaddr*)&srv_addr,sizeof(srv_addr));if(ret==-1){perror("cannot bind server socket");close(listen_fd);unlink(UNIX_DOMAIN);return 1;}//listen sockfdret=listen(listen_fd,1);if(ret==-1){perror("cannot listen the client connect request");close(listen_fd);unlink(UNIX_DOMAIN);return 1;}//have connect request use acceptlen=sizeof(clt_addr);com_fd=accept(listen_fd,(struct sockaddr*)&clt_addr,&len);if(com_fd<0){perror("cannot accept client connect request");close(listen_fd);unlink(UNIX_DOMAIN);return 1;}//read and printf sent client infoprintf("/n=====info=====/n");for(i=0;i<4;i++){memset(recv_buf,0,1024);int num=read(com_fd,recv_buf,sizeof(recv_buf));printf("Message from client (%d)) :%s/n",num,recv_buf);}close(com_fd);close(listen_fd);unlink(UNIX_DOMAIN);return 0;}客户端://c_unix.c#include <stdio.h>#include <sys/types.h>#include <sys/socket.h>#include <sys/un.h>#define UNIX_DOMAIN "/tmp/UNIX.domain"int main(void){int connect_fd;int ret;char snd_buf[1024];int i;static struct sockaddr_un srv_addr;//creat unix socketconnect_fd=socket(PF_UNIX,SOCK_STREAM,0);if(connect_fd<0){perror("cannot create communication socket");return 1;}srv_addr.sun_family=AF_UNIX;strcpy(srv_addr.sun_path,UNIX_DOMAIN);//connect serverret=connect(connect_fd,(struct sockaddr*)&srv_addr,sizeof(srv_addr)); if(ret==-1){perror("cannot connect to the server");close(connect_fd);return 1;}memset(snd_buf,0,1024);strcpy(snd_buf,"message from client");//send info serverfor(i=0;i<4;i++)write(connect_fd,snd_buf,sizeof(snd_buf));close(connect_fd);return 0;}使⽤套接字除了可以实现⽹络间不同主机间的通信外,还可以实现同⼀主机的不同进程间的通信,且建⽴的通信是双向的通信。

实验三_进程间的通信

实验三_进程间的通信

本科实验报告专用纸课程名称操作系统原理成绩评定实验项目名称进程间的通信指导教师实验项目编号实验项目类型实验地点学生姓名学号学院系专业实验时间年月日上午~月日上午温度℃湿度一、实验目的和要求1.实验目的:1.学习如何利用管道机制或消息缓冲队列进行进程间的通信,并加深对上述通信机制的理解。

提高学生分析问题和解决问题的能力,并学习撰写规范的科学研究报告(论文)。

2.实验要求:了解系统pipe(),msgsnd(),msgrcv()的功能和实现过程。

二、实验原理和主要内容1.实验内容:(1)编写一段程序,使用管道来实现父子进程之间的进程通信。

子进程向父进程发送自己的进程表示符,以及某字符串。

父进程则通过管道读出子进程发来的消息,将消息显示在屏幕上,然后终止。

(2)编写一段程序,使其用消息缓冲队列来实现client和server 进程之间的通信。

2.实验原理:(使用的系统调用命令说明或算法及程序详细设计)3.实验函数说明(1)包含头文件#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>(2)msgsnd()函数int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);//将消息送入消息队列参数:msqid:消息队列的识别码。

msgp:指向消息缓冲区的指针,此位置用来暂时存储发送和接收的消息,是一个用户可定义的通用结构,形态如下struct msgbuf {long mtype; /* 消息类型,必须> 0 */char mtext[1]; /* 消息文本*/};msgsz:消息的大小。

msgtyp:从消息队列内读取的消息形态。

如果值为零,则表示消息队列中的所有消息都会被读取。

msgflg:用来指明核心程序在队列没有数据的情况下所应采取的行动。

操作系统中的进程间通信与同步机制

操作系统中的进程间通信与同步机制

操作系统中的进程间通信与同步机制在计算机领域中,操作系统是一个必不可少的软件,它管理着计算机硬件和软件资源,并且为用户和应用程序提供了一个运行环境。

而进程是操作系统中执行中的程序实例,它是计算机资源分配、调度和执行的基本单位。

在一个操作系统中,多个进程常常需要进行通信和同步,以便进行数据传递和协调工作。

本文将讨论操作系统中的进程间通信与同步机制。

一、进程间通信(IPC)进程间通信,简称IPC(Inter-Process Communication),是指不同进程之间相互交换数据和信息的一种机制。

它允许进程之间共享资源、传递消息和协调活动。

在操作系统中,有几种常见的IPC机制,包括管道、共享内存、消息队列和套接字等。

1. 管道(Pipe)管道是一种最简单的进程间通信机制,它创建了一个字节流管道,一个进程的输出可以直接作为另一个进程的输入。

在Unix/Linux系统中,使用pipe()系统调用创建一个管道,典型的管道用法是通过fork()系统调用创建一个子进程,其中一个进程通过管道向另一个进程传递数据。

2. 共享内存(Shared Memory)共享内存是一种进程间通信的高效机制,它允许多个进程访问同一个内存区域,从而实现数据的共享。

在操作系统中,使用共享内存可以显著提高进程间通信的速度。

常见的共享内存接口包括shmget、shmat和shmdt等。

3. 消息队列(Message Queue)消息队列是一种进程间通信的方式,它通过在消息队列中传递和接收消息来实现进程间的数据交换。

在操作系统中,消息队列常用于解决生产者-消费者问题,其中一个进程将数据发送到消息队列,另一个进程从消息队列中接收数据。

4. 套接字(Socket)套接字是一种进程间通信的通用机制,它允许不同计算机上的进程通过网络进行通信。

套接字可以进行不同类型的通信,包括面向连接的socket和面向无连接的socket。

在操作系统中,套接字常用于实现分布式系统和网络应用程序。

III. Linux系统编程_ 30进程_4 进程间通信

III. Linux系统编程_ 30进程_4 进程间通信

第 30 章 进程 4. 进程间通信每个进程各自有不同的用户地址空间, 任何一个进程的全局变量在另一个进程中 都看不到,所以进程之间要交换数据必须通过内核,在内核中开辟一块缓冲区, 进程 1 把数据从用户空间拷到内核缓冲区,进程 2 再从内核缓冲区把数据读走, 内核提供的这种机制称为进程间通信(IPC,InterProcess Communication)。

如下图所示。

图 30.6. 进程间通信4.1. 管道管道是一种最基本的 IPC 机制,由 pipe 函数创建:#include <unistd.h>int pipe(int filedes[2]);调用 pipe 函数时在内核中开辟一块缓冲区(称为管道)用于通信,它有一个读 端一个写端, 然后通过 filedes 参数传出给用户程序两个文件描述符, filedes[0] 指向管道的读端,filedes[1]指向管道的写端(很好记,就像 0 是标准输入 1 是标准输出一样)。

所以管道在用户程序看起来就像一个打开的文件,通过 read(filedes[0]);或者 write(filedes[1]);向这个文件读写数据其实是在读 写内核缓冲区。

pipe 函数调用成功返回 0,调用失败返回-1。

开辟了管道之后如何实现两个进程间的通信呢?比如可以按下面的步骤通信。

图 30.7. 管道得到两个文件描述符指向管道的两端。

1. 父进程调用 pipe 开辟管道, 2. 父进程调用 fork 创建子进程,那么子进程也有两个文件描述符指 向同一管道。

3. 父进程关闭管道读端,子进程关闭管道写端。

父进程可以往管道里 写,子进程可以从管道里读,管道是用环形队列实现的,数据从写 端流入从读端流出,这样就实现了进程间通信。

例 30.7. 管道#include <stdlib.h> #include <unistd.h> #define MAXLINE 80int main(void) { int n; int fd[2]; pid_t pid; char line[MAXLINE];if (pipe(fd) < 0) { perror("pipe"); exit(1); } if ((pid = fork()) < 0) { perror("fork"); exit(1); } if (pid > 0) { /* parent */ close(fd[0]); write(fd[1], "hello world\n", 12); wait(NULL); } else { /* child */close(fd[1]); n = read(fd[0], line, MAXLINE);write(STDOUT_FILENO, line, n); } return 0; }使用管道有一些限制:•两个进程通过一个管道只能实现单向通信,比如上面的例子,父进 程写子进程读,如果有时候也需要子进程写父进程读,就必须另开 一个管道。

进程间通信的方式

进程间通信的方式

进程间通信的方式
进程间通信是指不同进程之间通过特定的方法进行数据传输和交流的过程。

常见的进程间通信方式有以下几种:
1. 管道:管道是一种单向的、按顺序存取的通信方式。

使用管道时,必须有一个进程向管道内写数据,另一个进程从管道中读取数据。

2. 共享内存:共享内存是指多个进程可以访问同一块内存空间,可以方便地共享数据。

但是需要注意对共享内存的操作必须同步,否则会出现数据冲突问题。

3. 消息队列:消息队列是指可以按照一定的规则,将一堆消息存储在一个队列中,进程可以从该队列中读取消息。

消息队列常常用来进行一些异步操作。

4. 套接字:套接字是一种通信机制,常用于建立客户端和服务器之间的网络连接。

套接字可以通过本地网络或者互联网进行通信。

5. 信号量:信号量是一种用于多进程同步的机制,通常用于控制多个进程对共享资源的访问。

当多个进程访问同一资源时,可以利用信号量避免出现竞争条件。

综上所述,不同的进程间通信方式适用于不同的场景和需求。

在实际开发中,需要结合具体的应用场景和技术选型进行选择和使用。

操作系统实验 进程通信

操作系统实验 进程通信

进程通信(实验二)【实验目的】:掌握用邮箱方式进行进程通信的方法,并通过设计实现简单邮箱理解进程通信中的同步问题以及解决该问题的方法。

【实验原理】:邮箱机制类似于日常使用的信箱。

对于用户而言使用起来比较方便,用户只需使用send()向对方邮箱发邮件receive()从自己邮箱取邮件,send()和receive()的内部操作用户无需关心。

因为邮箱在内存中实现,其空间有大小限制。

其实send()和receive()的内部实现主要还是要解决生产者与消费者问题。

【实验内容】:进程通信的邮箱方式由操作系统提供形如send()和receive()的系统调用来支持,本实验要求学生首先查找资料了解所选用操作系统平台上用于进程通信的系统调用具体形式,然后使用该系统调用编写程序进行进程间的通信,要求程序运行结果可以直观地体现在界面上。

在此基础上查找所选用操作系统平台上支持信号量机制的系统调用具体形式,运用生产者与消费者模型设计实现一个简单的信箱,该信箱需要有创建、发信、收信、撤销等函数,至少能够支持两个进程互相交换信息,比较自己实现的信箱与操作系统本身提供的信箱,分析两者之间存在的异同。

实验背景介绍进程间通信有如下目的:数据的传输,共享数据,通知事情,资源共享,进程控制。

进程间的通信机制(IPC),就是多进程相互通信,交换信息的方法。

Linux IPC机制包括,信号和管道是其中的两个,还支持传统的UNIX SYSTM-V 的IPC 机制。

信号主要用来通知进程异步事情的发生,最初信号设计的目的是为了处理错误,他们也用来作为最基本的IPC机制。

管道是单向的,先进先出,先入先出,无结构的,固定大小的数据流。

UNIX System V 机制中的三种进程间通信机制,它们是:消息队列:用于进程之间传递分类的格式化数据信号量:用于通信之间的同步控制。

信号量通常与共享存储器方式一起使用。

共享内存:使不同进程通过共享彼此的虚拟空间而达到相互对共享区操作和数据通信。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

IPC方法Linux环境下,进程地址空间相互独立,每个进程各自有不同的用户地址空间。

任何一个进程的全局变量在另一个进程中都看不到,所以进程和进程之间不能相互访问,要交换数据必须通过内核,在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信(IPC,InterProcess Communication)。

在进程间完成数据传递需要借助操作系统提供特殊的方法,如:文件、管道、信号、共享内存、消息队列、套接字、命名管道等。

随着计算机的蓬勃发展,一些方法由于自身设计缺陷被淘汰或者弃用。

现今常用的进程间通信方式有:①管道(使用最简单)②信号(开销最小)③共享映射区(无血缘关系)④本地套接字(最稳定)管道管道的概念:管道是一种最基本的IPC机制,作用于有血缘关系的进程之间,完成数据传递。

调用pipe系统函数即可创建一个管道。

有如下特质:1. 其本质是一个伪文件(实为内核缓冲区)2.由两个文件描述符引用,一个表示读端,一个表示写端。

3. 规定数据从管道的写端流入管道,从读端流出。

管道的原理: 管道实为内核使用环形队列机制,借助内核缓冲区(4k)实现。

管道的局限性:①数据自己读不能自己写。

②数据一旦被读走,便不在管道中存在,不可反复读取。

③由于管道采用半双工通信方式。

因此,数据只能在一个方向上流动。

④只能在有公共祖先的进程间使用管道。

常见的通信方式有,单工通信、半双工通信、全双工通信。

pipe函数创建管道int pipe(int pipefd[2]); 成功:0;失败:-1,设置errno函数调用成功返回r/w两个文件描述符。

无需open,但需手动close。

规定:fd[0] →r;fd[1] →w,就像0对应标准输入,1对应标准输出一样。

向管道文件读写数据其实是在读写内核缓冲区。

管道创建成功以后,创建该管道的进程(父进程)同时掌握着管道的读端和写端。

如何实现父子进程间通信呢?通常可以采用如下步骤:1.父进程调用pipe函数创建管道,得到两个文件描述符fd[0]、fd[1]指向管道的读端和写端。

2.父进程调用fork创建子进程,那么子进程也有两个文件描述符指向同一管道。

3.父进程关闭管道读端,子进程关闭管道写端。

父进程可以向管道中写入数据,子进程将管道中的数据读出。

由于管道是利用环形队列实现的,数据从写端流入管道,从读端流出,这样就实现了进程间通信。

练习:父子进程使用管道通信,父写入字符串,子进程读出并,打印到屏幕。

【pipe.c】思考:为甚么,程序中没有使用sleep函数,但依然能保证子进程运行时一定会读到数据呢?管道的读写行为使用管道需要注意以下4种特殊情况(假设都是阻塞I/O操作,没有设置O_NONBLOCK标志):1.如果所有指向管道写端的文件描述符都关闭了(管道写端引用计数为0),而仍然有进程从管道的读端读数据,那么管道中剩余的数据都被读取后,再次read会返回0,就像读到文件末尾一样。

2.如果有指向管道写端的文件描述符没关闭(管道写端引用计数大于0),而持有管道写端的进程也没有向管道中写数据,这时有进程从管道读端读数据,那么管道中剩余的数据都被读取后,再次read会阻塞,直到管道中有数据可读了才读取数据并返回。

3.如果所有指向管道读端的文件描述符都关闭了(管道读端引用计数为0),这时有进程向管道的写端write,那么该进程会收到信号SIGPIPE,通常会导致进程异常终止。

当然也可以对SIGPIPE信号实施捕捉,不终止进程。

具体方法信号章节详细介绍。

4.如果有指向管道读端的文件描述符没关闭(管道读端引用计数大于0),而持有管道读端的进程也没有从管道中读数据,这时有进程向管道写端写数据,那么在管道被写满时再次write会阻塞,直到管道中有空位置了才写入数据并返回。

总结:①读管道: 1. 管道中有数据,read返回实际读到的字节数。

2. 管道中无数据:(1) 管道写端被全部关闭,read返回0 (好像读到文件结尾)(2) 写端没有全部被关闭,read阻塞等待(不久的将来可能有数据递达,此时会让出cpu)②写管道: 1. 管道读端全部被关闭,进程异常终止(也可使用捕捉SIGPIPE信号,使进程不终止)2. 管道读端没有全部关闭:(1) 管道已满,write阻塞。

(2) 管道未满,write将数据写入,并返回实际写入的字节数。

练习:使用管道实现父子进程间通信,完成:ls | wc –l。

假定父进程实现ls,子进程实现wc。

ls命令正常会将结果集写出到stdout,但现在会写入管道的写端;wc –l 正常应该从stdin读取数据,但此时会从管道的读端读。

【pipe1.c】程序执行,发现程序执行结束,shell还在阻塞等待用户输入。

这是因为,shell →fork →./pipe1,程序pipe1的子进程将stdin重定向给管道,父进程执行的ls会将结果集通过管道写给子进程。

若父进程在子进程打印wc的结果到屏幕之前被shell调用wait回收,shell就会先输出$提示符。

练习:使用管道实现兄弟进程间通信。

兄:ls 弟:wc -l 父:等待回收子进程。

要求,使用“循环创建N个子进程”模型创建兄弟进程,使用循环因子i标示。

注意管道读写行为。

【pipe2.c】测试:是否允许,一个pipe有一个写端,多个读端呢?是否允许有一个读端多个写端呢?【pipe3.c】课后作业: 统计当前系统中进程ID大于10000的进程个数。

管道缓冲区大小可以使用ulimit –a 命令来查看当前系统中创建管道文件所对应的内核缓冲区大小。

通常为:pipe size (512 bytes, -p) 8也可以使用fpathconf函数,借助参数选项来查看。

使用该宏应引入头文件<unistd.h>long fpathconf(int fd, int name); 成功:返回管道的大小失败:-1,设置errno管道的优劣优点:简单,相比信号,套接字实现进程间通信,简单很多。

缺点:1. 只能单向通信,双向通信需建立两个管道。

2. 只能用于父子、兄弟进程(有共同祖先)间通信。

该问题后来使用fifo有名管道解决。

FIFOFIFO常被称为命名管道,以区分管道(pipe)。

管道(pipe)只能用于“有血缘关系”的进程间。

但通过FIFO,不相关的进程也能交换数据。

FIFO是Linux基础文件类型中的一种。

但,FIFO文件在磁盘上没有数据块,仅仅用来标识内核中一条通道。

各进程可以打开这个文件进行read/write,实际上是在读写内核通道,这样就实现了进程间通信。

创建方式:1. 命令:mkfifo 管道名2. 库函数:int mkfifo(const char *pathname, mode_t mode); 成功:0;失败:-1一旦使用mkfifo创建了一个FIFO,就可以使用open打开它,常见的文件I/O函数都可用于fifo。

如:close、read、write、unlink等。

【fifo_w.c/fifo_r.c】共享存储映射文件进程间通信使用文件也可以完成IPC,理论依据是,fork后,父子进程共享文件描述符。

也就共享打开的文件。

练习:编程测试,父子进程共享打开的文件。

借助文件进行进程间通信。

【fork_shared_fd.c】思考,无血缘关系的进程可以打开同一个文件进行通信吗?为什么?存储映射I/O存储映射I/O(Memory-mapped I/O)使一个磁盘文件与存储空间中的一个缓冲区相映射。

于是当从缓冲区中取数据,就相当于读文件中的相应字节。

于此类似,将数据存入缓冲区,则相应的字节就自动写入文件。

这样,就可在不适用read和write函数的情况下,使用地址(指针)完成I/O操作。

使用这种方法,首先应通知内核,将一个指定文件映射到存储区域中。

这个映射工作可以通过mmap函数来实现。

mmap函数void *mmap(void *adrr,size_t length,int prot, int flags, int fd, off_t offset);返回:成功:返回创建的映射区首地址;失败:MAP_FAILED宏参数:addr: 建立映射区的首地址,由Linux内核指定。

使用时,直接传递NULLlength:欲创建映射区的大小prot:映射区权限PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITEflags:标志位参数(常用于设定更新物理区域、设置共享、创建匿名映射区)MAP_SHARED: 会将映射区所做的操作反映到物理设备(磁盘)上。

MAP_PRIVATE: 映射区所做的修改不会反映到物理设备。

fd:用来建立映射区的文件描述符offset:映射文件的偏移(4k的整数倍)munmap函数同malloc函数申请内存空间类似的,mmap建立的映射区在使用结束后也应调用类似free的函数来释放。

int munmap(void *addr, size_t length); 成功:0;失败:-1借鉴malloc和free函数原型,尝试装自定义函数smalloc,sfree来完成映射区的建立和释放。

思考函数接口该如何设计?【smalloc.c】mmap注意事项【mmap.c】思考:1. 可以open的时候O_CREAT一个新文件来创建映射区吗?2. 如果open时O_RDONLY, mmap时PROT参数指定PROT_READ|PROT_WRITE会怎样?3. 文件描述符先关闭,对mmap映射有没有影响?4. 如果文件偏移量为1000会怎样?5. 对mem越界操作会怎样?6. 如果mem++,munmap可否成功?7.mmap什么情况下会调用失败?8. 如果不检测mmap的返回值,会怎样?总结:使用mmap时务必注意以下事项:1.创建映射区的过程中,隐含着一次对映射文件的读操作。

2.当MAP_SHARED时,要求:映射区的权限应<=文件打开的权限(出于对映射区的保护)。

而MAP_PRIVATE则无所谓,因为mmap中的权限是对内存的限制。

3.映射区的释放与文件关闭无关。

只要映射建立成功,文件可以立即关闭。

4.特别注意,当映射文件大小为0时,不能创建映射区。

所以:用于映射的文件必须要有实际大小!!mmap使用时常常会出现总线错误,通常是由于共享文件存储空间大小引起的。

5.munmap传入的地址一定是mmap的返回地址。

坚决杜绝指针++操作。

6.如果文件偏移量必须为4K的整数倍7.mmap创建映射区出错概率非常高,一定要检查返回值,确保映射区建立成功再进行后续操作。

mmap父子进程通信父子等有血缘关系的进程之间也可以通过mmap建立的映射区来完成数据通信。

相关文档
最新文档