进程间通信(1)

合集下载

计算机操作系统习题及答案(4)

计算机操作系统习题及答案(4)

第4章进程同步与通信1)选择题(1)在操作系统中,P、V操作是一种_D__。

A. 机器指令B. 系统调用命令C. 作业控制命令D. 低级进程通信原语(2)若信号量S的初值为2,当前值为-1,则表示有_B__等待进程。

A. 0个B. l个C. 2个D. 3个(3)在直接通信方式中,系统提供两条通信原语进行发送和接收,其中Send原语中参数应是_C_。

A. sender,messageB. sender,mailboxC. receiver,messageD. receiver,mailbox(4)下述那个选项不是管程的组成部分_A__。

A. 管程外过程调用管程内数据结构的说明B. 管程内对数据结构进行操作的一组过程C. 局部于管程的共享数据说明D. 对局部于管程的数据结构设置初值的语句(5)某通信方式通过共享存储区来实现,其属于_D__。

A. 消息通信B. 低级通信C. 管道通信D. 高级通信(6)用P、V操作管理临界区时,信号量的初值应定义为__C__。

A. -1B. 0C. 1D. 任意值(7)临界区是_B__。

A. 一个缓冲区B. 一段程序C. 一段共享数据区D. 一个互斥资源(8)信箱通信是一种_D__通信方式。

A. 直接通信B. 信号量C. 低级通信D. 间接通信(9)对于两个并发进程,设互斥信号量为mutex,若mutex=0则__A_。

A. 表示有一个进程进入临界区B. 表示没有进程进入临界区C. 表示有一个进程进入临界区,另一个进程等待进入D. 表示有两个进程进入临界区(10)对信号量S执行V操作后,下述选项正确的是_C__。

A. 当S小于等于0时唤醒一个阻塞进程B. 当S小于0时唤醒一个阻塞进程C. 当S小于等于0时唤醒一个就绪进程D. 当S小于0时唤醒一个就绪进程(11)在消息缓冲通信中,消息队列属于_A__资源。

A. 临界B. 共享C. 永久D. 可剥夺(12)在消息缓冲通信机制中,使用的临界资源是_D__。

进程间通信的几种方法

进程间通信的几种方法

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QT进程间通信详细介绍及QProcess机制分析

QT进程间通信详细介绍及QProcess机制分析

QT进程间通信详细介绍及QProcess机制分析1、QT通信机制为了更好的实现QT的信息交互,在QT系统中创建了较为完善的通信机制。

QT的通信可分为QT内部通信和外部通信两大类。

对于这两类通信机制及应用场合做如以下分析:(1)QT内部对象间通信在图形用户界面编程中,经常需要将一个窗口部件的变化通知给窗口的其它部件使其产生相应的变化。

对于这种内部对象间的通信,QT主要采用了信号和槽的机制。

这种机制是QT区别于其他GUI工具的核心机制。

在大部分的GUI工具中,通常为可能触发的每种行为通过定义回调函数来实现。

这种回调函数是一个指向函数的指针,在进行函数回调执行时不能保证所传递的函数参数类型的正确性,因此容易造成进程的崩溃。

在QT中,信号和槽的机制取代了这种繁杂的、易崩溃的对象通信机制。

信号是当对象状态改变时所发出的。

槽是用来接收发射的信号并响应相应事件的类的成员函数。

信号和槽的连接是通过connect()函数来实现的。

例如,实现单击按钮终止应用程序运行的代码connect(button , SIGNAL(clicked()) , qApp , SLOT(quit()) );实现过程就是一个button被单击后会激发clicked信号,通过connect()函数的连接qApp会接收到此信号并执行槽函数quit()。

在此过程中,信号的发出并不关心什么样的对象来接收此信号,也不关心是否有对象来接收此信号,只要对象状态发生改变此信号就会发出。

此时槽也并不知晓有什么的信号与自己相联系和是否有信号与自己联系,这样信号和槽就真正的实现了程序代码的封装,提高了代码的可重用性。

同时,信号和槽的连接还实现了类型的安全性,如果类型不匹配,它会以警告的方式报告类型错误,而不会使系统产生崩溃。

(2)QT与外部设备间通信QT与外部通信主要是将外部发来的消息以事件的方式进行接收处理。

外部设备将主要通过socket与QT应用程序进行连接。

Android进程间通信(一):AIDL使用详解

Android进程间通信(一):AIDL使用详解

Android进程间通信(⼀):AIDL使⽤详解⼀、概述AIDL是Android Interface Definition Language的缩写,即Android接⼝定义语⾔。

它是Android的进程间通信⽐较常⽤的⼀种⽅式。

Android中,每⼀个进程都有⾃⼰的Dalvik VM实例,拥有⾃⼰的独⽴的内存空间,进程与进程之间不共享内存,这就产⽣了进程间通信的需求。

⼆、语法AIDL是Android接⼝定义语⾔,是⼀门语⾔,所以它拥有⾃⼰的语法和特性。

(⼀)数据类型AIDL⽀持的数据类型包括以下⼏种:1. Java的8种基本数据类型:int,short,long,char,double,byte,float,boolean;2. CharSequence类型,如String、SpannableString等;3. ArrayList,并且T必须是AIDL所⽀持的数据类型;4. HashMap<K,V>,并且K和V必须是AIDL所⽀持的数据类型;5. 所有Parceable接⼝的实现类,因为跨进程传输对象时,本质上是序列化与反序列化的过程;6. AIDL接⼝,所有的AIDL接⼝本⾝也可以作为可⽀持的数据类型;有两个需要注意的地⽅:1、在Java中,如果⼀个对象和引⽤它的类在同⼀个package下,是不需要导包的,即不需要import,⽽在AIDL中,⾃定义的Parceable对象和AIDL接⼝定义的对象必须在所引⽤的AIDL⽂件中显式import进来,不管这些对象和所引⽤它们的AIDL⽂件是否在同⼀个包下。

2、如果AIDL⽂件中使⽤到⾃定义的Parceable对象,则必须再创建⼀个与Parceable对象同名的AIDL⽂件,声明该对象为Parceable类型,并且根据上⼀条语法规定,在AIDL⽂件中进⾏显式import。

(⼆)⽂件类型1. 所有AIDL⽂件都是以.aidl作为后缀的;2. 根据⽤途区分,AIDL⽂件的有两种,⼀种是⽤于定义接⼝,另⼀种是⽤于声明parceable对象,以供其他AIDL⽂件使⽤;(三)定向tagAIDL中,除了基本数据类型,其他类型的⽅法参数都必须标上数据在跨进程通信中的流向:in、out或inout:1、in表⽰输⼊型参数:只能由客户端流向服务端,服务端收到该参数对象的完整数据,但服务端对该对象的后续修改不会影响到客户端传⼊的参数对象;2、out表⽰输出型参数:只能由服务端流向客户端,服务端收到该参数的空对象,服务端对该对象的后续修改将同步改动到客户端的相应参数对象;3、inout表⽰输⼊输出型参数:可在客户端与服务端双向流动,服务端接收到该参数对象的完整数据,且服务端对该对象的后续修改将同步改动到客户端的相应参数对象;定向tag需要⼀定的开销,根据实际需要去确定选择什么tag,不能滥⽤。

Python中的进程间通信

Python中的进程间通信

Python中的进程间通信进程间通信(IPC,Inter-Process Communication)是一种进程之间传递数据和消息的方式。

在操作系统中,进程是程序在运行时分配给它的内存空间和系统资源的实例。

不同的进程可能运行在不同的计算机上或者同一台计算机上的不同CPU中。

进程间通信是实现多个进程相互合作完成任务的必要手段之一。

进程间通信的方式可以分为多种,包括管道、消息队列、共享内存、信号量等。

Python通过提供不同的模块实现了这些方式,使得进程可以在Python中相互通信,完成不同的任务,实现高效的协作。

1.管道(Pipe)管道是在两个进程之间建立的一条通信通道,可以进行双向通信。

通常情况下,一个进程的输出被重定向到管道中,另一个进程则从管道中读取输入。

在Python中可以使用os模块的pipe()方法来建立管道。

示例代码:```pythonimport ospipe = os.pipe()pid = os.fork()if pid == 0:#子进程从管道中读取数据os.close(pipe[1])data = os.read(pipe[0], 1024)print(f"子进程读取到的数据:{data}") os._exit(0)else:#父进程向管道中写入数据os.close(pipe[0])os.write(pipe[1], b"Hello, Pipe!")os.wait()```在上面的代码中,我们先调用了pipe()方法创建了一个管道,然后使用fork()方法创建了一个子进程。

子进程从管道中读取数据,父进程则向管道中写入数据,最终等待子进程结束。

2.消息队列(Message Queue)消息队列是一种进程间通信机制,可以在不同的进程之间传递消息。

消息队列通常是先进先出的,每个消息都有一个标识符来标记其类型。

在Python中可以使用sysv_ipc模块来使用消息队列。

进程间通信的方式有哪些?

进程间通信的方式有哪些?

进程间通信的⽅式有哪些?
进程间通信的⽅式有哪些?
1、进程间通讯⽅式有:管道,信号,信号量,消息队列,共享内存,套接字共六种
2、管道:管道分为有名管道和⽆名管道,其中⽆名管道是⼀种半双⼯的通信⽅式,数据只能单向流动,⽽且只能在具有亲缘关系的进程间使⽤,⼀般⽤于两个不同进程之间的通信。

有名管道也是⼀种半双⼯的通信⽅式,但它允许⽆亲缘关系进程间的通信。

3、信号:信号是⼀种⽐较复杂的通信⽅式,信号产⽣的条件:按键、硬件异常、进程调⽤kill函数将信号发送给另⼀个进程、⽤户调⽤kill命令将信号发送给其他进程,传递的消息⽐较少⽤于通知接收进程某个时间已经发⽣
4、信号量:信号量是⼀个计数器,可以⽤来控制多个线程对共享资源的访问,它不是⽤于交换⼤批数据,⽽⽤于多线程之间的同步。

他常作为⼀种锁机制。

因此,主要作为进程间以及同⼀个进程内不同线程之间的同步⼿段
5、消息队列:消息队列是消息的链表,存放在内核中并由消息队列标识符标识,消息队列克服了信号传递信息少,管道只能承载⽆格式字节流以及缓冲区⼤⼩受限等特点。

6、共享内存:共享内存就是映射⼀段能被其他进程所访问的内存,这段共享内存由⼀个进程创建,但多个进程都可以访问。

他往往与其他通信机制,如信号量配合使⽤,来实现进程间的同步和通信。

7、套接字:套接字可⽤于不同及其间的进程通信。

流式套接字: 提供可靠的,⾯向连接的通讯流
数据包套接字:定义⼀种⽆连接的服务,通过相互独⽴的报⽂进⾏传输,是⽆序的。

VC_进程间通信

VC_进程间通信
}
//--------------------------------------------------------------------
void CDataSendDlg::OnSendRegmsg()
{????????????????????????????? // 更新数据
void CDataRecvDlg::OnRegReceiveMsg(WPARAM wParam,LPARAM lParam)
{
// 增加用户自定义程序代码

}
其中OnUserReceiveMsg()函数为WM_COMM消息的映射函数,OnRegReceiveMsg()函数为wm_nRegMsg消息的映射函数。可以看出,这两种消息的映射函数形式是一样的。
在接收消息的程序中,除与发送消息的程序需要定义相同的消息外,还需要定义相应的消息映射和消息映射函数,消息的映射方法如下:
ON_MESSAGE(WM_COMM,OnUserReceiveMsg)
ON_REGISTERED_MESSAGE(wm_nRegMsg,OnRegReceiveMsg)
与以上消息映射对应的函数定义如下:
l?????? 间接通信:借助于收发双方进程之外的共享数据结构作为通信中转,如剪贴板。通常接收和发送方的数目可以是任意的。
(3)本地通信和远程通信
l?????? 本地通信方式:这种通信又称之为同机通信,它是在同一台计算机上的程序之间进行的,也就是说客户进程和服务进程位于同一台计算机上。
l?????? 远程通信方式:这种通信又称之为网间的进程通信,要解决的是不同主机进程间的相互通信问题(可把同机进程通信看作是其中的特例)。在这种通信中,首先要解决的是网络间的进程标识问题。同一主机上,不同进程可用进程号(process ID)唯一标识。但在网络环境下,各主机独立分配的进程号不能唯一标识该进程。例如,主机A赋予某个进程号5,在B机中也可以存在5号进程,因此,“5号进程”这句话就没有意义了。其次,操作系统支持的网络协议众多,不同协议的工作方式不同,地址格式也不同。因此,网间的进程通信还要解决多重协议的识别问题。

进程间通信和线程间通信的几种方式

进程间通信和线程间通信的几种方式

进程间通信和线程间通信的⼏种⽅式进程进程(Process)是计算机中的程序关于某数据集合上的⼀次运⾏活动,是系统进⾏资源分配和调度的基本单位,是结构的基础。

在早期⾯向进程设计的计算机结构中,进程是程序的基本执⾏实体;在当代⾯向线程设计的计算机结构中,进程是线程的容器。

程序是指令、数据及其组织形式的描述,进程是程序的实体。

进程是⼀个具有独⽴功能的程序关于某个数据集合的⼀次运⾏活动。

它可以申请和拥有系统资源,是⼀个动态的概念,是⼀个活动的实体。

它不只是程序的,还包括当前的活动,通过的值和处理的内容来表⽰。

进程的概念主要有两点:第⼀,进程是⼀个实体。

每⼀个进程都有它⾃⼰的地址空间,⼀般情况下,包括区域(text region)、数据区域(data region)和(stack region)。

⽂本区域存储处理器执⾏的代码;数据区域存储变量和进程执⾏期间使⽤的动态分配的内存;堆栈区域存储着活动过程调⽤的指令和本地变量。

第⼆,进程是⼀个“执⾏中的程序”。

程序是⼀个没有⽣命的实体,只有器赋予程序⽣命时(操作系统执⾏之),它才能成为⼀个活动的实体,我们称其为。

进程是具有⼀定独⽴功能的程序关于某个数据集合上的⼀次运⾏活动,进程是系统进⾏资源分配和调度的⼀个独⽴单位。

每个进程都有⾃⼰的独⽴内存空间,不同进程通过进程间通信来通信。

由于进程⽐较重量,占据独⽴的内存,所以上下⽂进程间的切换开销(栈、寄存器、虚拟内存、⽂件句柄等)⽐较⼤,但相对⽐较稳定安全。

线程线程是进程的⼀个实体,是CPU调度和分派的基本单位,它是⽐进程更⼩的能独⽴运⾏的基本单位.线程⾃⼰基本上不拥有系统资源,只拥有⼀点在运⾏中必不可少的资源(如程序计数器,⼀组寄存器和栈),但是它可与同属⼀个进程的其他的线程共享进程所拥有的全部资源。

线程间通信主要通过共享内存,上下⽂切换很快,资源开销较少,但相⽐进程不够稳定容易丢失数据。

⼀个线程可以创建和撤消另⼀个线程,同⼀进程中的多个线程之间可以并发执⾏。

windows进程间通信的几种方法

windows进程间通信的几种方法

windows进程间通信的几种方法(实用版4篇)目录(篇1)1.引言2.Windows进程间通信概述3.管道通信4.共享内存通信5.消息队列通信6.套接字通信7.结论正文(篇1)一、引言Windows操作系统以其强大的功能和灵活性,吸引了众多用户。

在Windows平台上,进程间通信(IPC)是实现应用程序之间数据交换和协作的关键。

本文将介绍几种常用的Windows进程间通信方法。

二、Windows进程间通信概述Windows进程间通信是指不同进程之间通过某种机制实现数据交换。

它允许应用程序在不同的线程或进程之间传递信息,从而实现协同工作。

在Windows平台上,有多种进程间通信机制可供选择,包括管道、共享内存、消息队列和套接字等。

三、管道通信1.概述:管道是一种用于不同进程之间数据交换的同步机制。

它提供了一种单向数据流,可实现父子进程之间的通信。

2.创建:使用CreateNamedPipe函数创建命名管道或使用CreatePipe函数创建匿名管道。

3.读取/写入:使用ReadFile和WriteFile函数进行数据的读取和写入。

4.关闭:使用CloseHandle函数关闭管道句柄。

四、共享内存通信1.概述:共享内存允许多个进程访问同一块内存区域,从而实现数据共享和快速数据访问。

2.创建:使用CreateFileMapping函数创建共享内存映射。

3.读取/写入:使用MapViewOfFile函数将共享内存映射到进程的地址空间,并进行数据的读取和写入。

4.同步:使用原子操作或信号量进行数据的同步和互斥访问。

五、消息队列通信1.概述:消息队列允许不同进程之间传递消息,实现异步通信。

它可以实现消息的批量发送和接收,适用于高并发的消息传递场景。

2.创建:使用CreateMailslot函数创建消息队列。

3.发送/接收:使用SendMessage函数发送消息,使用SendMessage 函数的异步版本接收消息。

进程间通信常见方法

进程间通信常见方法

进程间通信常见方法
进程间通信是操作系统中的重要概念,它涉及不同进程之间的数据传输和信息
共享。

在现代操作系统中,常见的进程间通信方法包括以下几种:
1. 管道:管道是最简单的进程间通信方法之一,适用于具有父子进程关系的进程。

它通过创建一个管道,将一个进程的输出连接到另一个进程的输入,实现它们之间的数据传输。

2. 消息队列:消息队列是一种以消息为单位进行进程间通信的方法。

它通过创
建一个消息队列,进程可以向队列中发送消息,并由其他进程接收。

这种通信方式可以实现进程之间的异步通信,提供了较大的灵活性。

3. 共享内存:共享内存是一种高效的进程间通信方法,它允许多个进程访问同
一块物理内存。

通过映射同一块共享内存区域到不同的进程地址空间,进程可以直接读写共享内存中的数据,实现高速的数据交换。

4. 套接字(Socket):套接字是一种用于网络编程的通信机制,也可以在本地
进程间进行通信。

它提供了一种可靠的、面向连接的方式来实现进程间的数据传输。

通过使用套接字,进程可以在不同主机或同一主机的不同进程之间进行通信。

这些是常见的进程间通信方法,每种方法都有其适用的场景和特点。

在实际应
用中,我们可以根据具体需求选择合适的通信方法来实现进程间的数据传输和信息共享。

了解这些通信方法的特点和使用方式,对于处理多进程间的数据交互是非常重要的。

嵌入式开发中的进程间通信

嵌入式开发中的进程间通信

嵌入式开发中的進程間通信在嵌入式开发中,进程间通信(Inter-Process Communication,IPC)是一个非常重要的概念和技术。

嵌入式系统中的多个进程或任务可能需要相互通信和协作,以完成复杂的功能和任务。

本文将介绍嵌入式开发中的进程间通信技术,包括原理、常用方法和应用。

一、进程间通信的概念和原理在嵌入式系统中,进程是指执行中的程序实例,可以独立运行并具有自己的地址空间和上下文。

不同的进程可能需要相互通信和共享资源,以实现系统的功能和目标。

进程间通信即是指不同进程之间进行数据传递和信息交流的过程。

进程间通信的原理基于操作系统的支持,通过提供一组机制和接口,使得不同进程可以安全地进行数据传输和共享。

进程间通信可以在同一个处理器上的不同任务之间进行,也可以在不同处理器上的任务之间进行。

二、进程间通信的常用方法在嵌入式系统中,有多种方法可以实现进程间通信。

下面将介绍几种常用的方法。

1. 共享内存共享内存是一种高效的进程间通信方法,它允许不同的进程共享同一块物理内存区域。

不同的进程可以通过读写共享内存来实现数据的传递和共享。

共享内存的关键在于同步和互斥机制,确保各个进程对共享内存的访问不会发生冲突和竞争。

2. 信号量信号量是一种用于进程间同步和互斥的机制。

它可以用来解决多个进程访问共享资源时可能发生的冲突和竞争问题。

通过设置信号量的初值和对信号量进行P(阻塞)和V(唤醒)操作,不同进程可以按照特定的顺序进行访问和操作共享资源。

3. 消息队列消息队列是一种基于消息传递的进程间通信方法。

不同进程可以通过向消息队列发送消息和从消息队列接收消息来进行通信。

消息队列一般按照先进先出(FIFO)的原则进行消息的排队和传递。

4. 管道和套接字管道和套接字是一种基于文件描述符的进程间通信方法。

它们允许不同进程之间通过读写文件描述符进行数据传输和通信。

管道一般用于同一台主机上的进程通信,而套接字则可以在不同主机上的进程之间进行通信。

安卓进程间通信的四种方式(含案例)

安卓进程间通信的四种方式(含案例)

安卓进程间通信的四种方式(含案例)1. BinderBinder是Android系统中的一种轻量级的进程间通信机制。

它基于C++语言实现,允许多个进程共享数据和调用彼此的方法。

Binder有三个角色:服务端、客户端和服务管理器。

服务端提供服务并注册到服务管理器,客户端通过服务管理器获取服务对象并进行通信。

例如,一个应用可能需要使用另一个应用提供的服务,通过Binder可以跨进程访问服务的方法。

服务端可以实现一个抽象类,并将其注册到服务管理器,客户端通过服务管理器获取服务对象,并调用其方法。

2. ContentProviderContentProvider是Android提供的一种数据共享机制,能够使一个应用程序的数据集对其他应用程序可见。

ContentProvider提供了一系列的方法,允许其他应用程序通过URI进行数据的访问、插入、更新和删除。

例如,一个应用程序有一个存储用户信息的数据库,通过将ContentProvider暴露给其他应用程序,其他应用程序可以通过URI查询、插入、更新和删除用户信息。

3.广播广播是Android提供的进程间通信的一种方式。

广播通过Intent传递消息,发送广播的应用程序将消息发送给其他应用程序,并且其他应用程序可以通过注册广播接收器来接收这些消息。

例如,一个应用程序可能发送一个自定义广播来通知其他应用程序有关一些事件的发生,其他应用程序可以注册广播接收器来接收这个广播并执行相应的操作。

4. MessengerMessenger是一种轻量级的IPC机制,它是基于Binder实现的。

Messenger可以在不同的进程间发送Message对象,通过Message对象传递数据。

例如,一个应用程序可以创建一个Messenger实例,并将其传递给另一个应用程序,另一个应用程序可以通过Messenger向第一个应用程序发送消息,并通过消息携带数据。

以上是安卓进程间通信的四种方式,每种方式都有自己的特点和适用场景。

实验一 进程间通信

实验一  进程间通信

进程间通信班级:网络081姓名:甘春泉学号:200800824126实验一进程间通信一、实验目的在本实验中,通过对文件映射对象的了解,来加深对Windows 2000线程同步的理解.回顾系统进程、线程的有关概念,加深对Windows xp线程间通讯的理解;了解文件映射对象;通过分析实验程序,了解线程如何通过文件映射对象发送数据;了解在进程中如何使用文件映射对象.二、背景知识共享内存:Windows xp提供了一种在文件中处理数据的方法,名为内存映射文件,也称为文件映射.文件映射对象是在虚拟内存中分配的永久或临时文件对象区域 (如果可能的话,可大到整个文件) ,可将其看作是二进制的数据块.使用这类对象,可获得直接在内存中访问文件内容的能力.文件映射对象提供了强大的扫描文件中数据的能力,而不必移动文件指针.对于多线程的读写操作来说,这一点特别有用,因为每个线程都可能想要把读取指针移动到不同的位置去——为了防止这种情况,就需要使用某种线程同步机制保护文件.在CreateFileMapping() API中,一个新的文件映射对象需要有一个永久的文件对象(由CreateFile() 所创建) .该函数使用标准的安全性和命名参数,还有用于允许操作 (如只读) 的保护标志以及映射的最大容量.随后可根据来自OpenFileMapping() API的其他线程或进程使用该映射——这与事件和互斥体的打开进程是非常类似的.内存映射文件对象的另一个强大的应用是可请求系统创建一个运行映射的临时文件.该临时文件提供一个临时的区域,用于线程或进程互相发送大量数据,而不必创建或保护磁盘上的文件.利用向创建函数中发送INVALID_HANDLE_VALUE来代替真正的文件句柄,就可创建这一临时的内存映射文件;指令内核使用系统页式文件来建立支持映射的最大容量的临时数据区.为了利用文件映射对象,进程必须将对文件的查看映射到它的内存空间中.也就是说,应该将文件映射对象想象为进程的第一步,在这一步中,当查看实际上允许访问的数据时,附加有共享数据的安全性和命名方式.为了获得指向内存区域的指针需要调用MapViewOfFile() API,此调用使用文件映射对象的句柄作为其主要参数.此外还有所需的访问等级 (如读-写) 和开始查看时文件内的偏移和要查看的容量.该函数返回一个指向进程内的内存的指针,此指针可有多种编程方面的应用 (但不能超过访问权限) .当结束文件映射查看时,必须用接受到的指针调用UnmapViewOfFlie() API,然后再根据映射对象调用CloseHandle() API,从而将其清除二、实验内容1.编译运行项目Lab5.1\SHAREMEM.DSW,观察运行结果,并阅读和分析实验程序.2. Lab5.2目录下的示例程序:ProcessA.exe,ProcessB.exe用三种方法实现了进程通信.(1)进程A中输入一些字符,点“利用SendMessage发送消息”按钮可将消息发到进程B.(2)在进程A中输入一些字符,点“写数据到内存映像文件”按钮,然后在进程B中点“从内存映像文件读数据”按钮可收到消息.(3)先在进程B中点“创建管道并接收数据”按钮,然后在进程A中输入一些字符,点“写数据到管道文件”按钮可将消息发到进程B(重复第3步每次可发一条消息).消息传递数据通信可参考SendMessage.txt,共享内存通信可参考MemFile.txt,管道通信可参考Pipe.txt.3.编写程序利用WM_COPYDATA消息机制,实现线程间的通信.关键代码如下:发送端:void CSendDataDlg::OnBtSend() //实现CString类型数据的发送{ UpdateData(TRUE);if (m_szData.IsEmpty()){ m_szData = _T("Hello");UpdateData(FALSE); }HWND hWndRcv = ::FindWindow(NULL,"Receiver");if (hWndRcv == NULL){ AfxMessageBox(_T("找不到接收窗口,发送不成功"));return ; }COPYDATASTRUCT cpd;cpd.dwData = STRING; //标志为CString类型cpd.cbData = m_szData.GetLength() + 1; //GetLength()只是取得实际字符的长度,没有包括'\0'.cpd.lpData = (void*)m_szData.GetBuffer(cpd.cbData);::SendMessage(hWndRcv,WM_COPYDATA,(WPARAM)this->m_hWnd,(LPARAM)&cpd); m_szData.ReleaseBuffer();AfxMessageBox(_T("发送成功")); }接收端:BOOL CReceiverDlg::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct) {m_szData += (LPCSTR)(pCopyDataStruct->lpData);UpdateData(FALSE); }三.实验心得通过本次实验,我对进程间通信的机制有了基本的了解,熟悉了一些常用的通信方式,例如剪贴板方式、命名管道、匿名管道、邮槽、wm_copydata方式等,其中较为简单的一种方式是wm_copydata方式,但是其能力却极其有限,只能发送小数据量。

实验三_进程间的通信

实验三_进程间的通信

本科实验报告专用纸课程名称操作系统原理成绩评定实验项目名称进程间的通信指导教师实验项目编号实验项目类型实验地点学生姓名学号学院系专业实验时间年月日上午~月日上午温度℃湿度一、实验目的和要求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。

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

Shell脚本编写的高级技巧使用共享内存和进程间通信

Shell脚本编写的高级技巧使用共享内存和进程间通信

Shell脚本编写的高级技巧使用共享内存和进程间通信共享内存和进程间通信是Shell脚本编写中非常重要的技巧和概念。

它们可以帮助我们实现进程之间的数据传递和通信。

本文将介绍使用共享内存和进程间通信的高级技巧,以及如何在Shell脚本中应用这些技巧。

一、共享内存1.1 什么是共享内存共享内存是一种用于进程间通信的机制,它允许不同的进程访问同一块内存区域。

通过共享内存,多个进程可以实现数据共享,从而提高程序的效率。

1.2 在Shell脚本中使用共享内存在Shell脚本中使用共享内存需要借助一些系统命令和工具,比如ipcs、ipcrm等。

下面是一个使用共享内存实现数据传递的例子:```shell#!/bin/bash# 创建共享内存shm_id=$(ipcs -m | grep "0x" | awk '{ print $2 }')if [ -z "$shm_id" ]; thenshm_id=$(ipcmk -M | awk '{ print $NF }')fi# 写入数据data="Hello, shared memory!"echo -n "$data" > /dev/shm/$shm_id# 读取数据data=$(cat /dev/shm/$shm_id)echo "Shared memory data: $data"# 删除共享内存ipcrm -M $shm_id```这个脚本首先用ipcs命令检查是否已存在共享内存,如果不存在则用ipcmk命令创建一块共享内存。

然后,它通过echo命令将数据写入共享内存,再通过cat命令读取共享内存中的数据。

最后,使用ipcrm 命令删除共享内存。

二、进程间通信2.1 什么是进程间通信进程间通信(Inter-Process Communication,简称IPC)是指不同进程之间进行数据交换和通信的机制。

ipc一二三级标准(一)

ipc一二三级标准(一)

ipc一二三级标准(一)IPC一二三级标准什么是IPC?IPC是Inter Process Communication的缩写,即进程间通信,是操作系统中进程间互相传递信息的一种机制。

为什么需要IPC?在多进程的情况下,不同进程之间需要相互协作完成任务。

而进程之间如果不能相互通信,那么这些进程之间就不能进行有效的协作,从而导致程序无法正常运行。

IPC一二三级标准是什么?IPC一二三级标准是指进程间通信的三个不同级别的标准。

其中,第一级是指通过内核数据结构进行进程间通信,第二级是指通过消息队列进行进程间通信,第三级是指通过共享内存进行进程间通信。

IPC一级标准IPC一级标准也被称为管道通信,它是通过内核数据结构进行进程间通信。

在该级别的通信中,数据是按照FIFO(先进先出)的顺序进行传递的,在进程间传递上也是单项的。

这种通信方法适用于有父子进程关系,或者进程之间存在严格的输送顺序的情况下。

IPC二级标准IPC二级标准也被称为消息队列通信,它是通过消息队列进行进程间通信。

在该级别的通信中,数据是以消息的形式进行传递的。

与IPC一级标准不同的是,IPC二级标准支持进程间双向通信,并且数据的传递是异步的。

IPC三级标准IPC三级标准也被称为共享内存通信,它是通过共享内存进行进程间通信。

在该级别的通信中,数据是通过共享同一块物理内存来实现的。

不同进程可以直接访问共享内存,从而实现数据的共享。

与IPC一二级标准不同的是,IPC三级标准的数据传递是最快的。

总结通过本文的介绍,我们了解了IPC的概念以及IPC一二三级标准。

不同的IPC级别适用于不同的场景,开发人员需要根据实际需求来选择适合的IPC通信方式。

IPC一二三级标准的优缺点IPC一二三级标准在实际应用中有不同的优缺点。

IPC一级标准的优缺点优点•简单易用,不需要太多的系统资源;•用于管道通信的进程必须是有亲缘关系的进程,所以可以保证数据传输的安全性;•管道通信的方式适用于数据流动性比较低的场景,比如在进程间传递文件等静态资源时比较方便。

进程间通信的方式

进程间通信的方式

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

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

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

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

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

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

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

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

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

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

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

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

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

进程通信原理

进程通信原理

进程通信原理
进程通信是实现并发进程之间相互合作的重要手段。

其原理主要包括以下几个方面:
1. 进程间通信:当两个或多个进程在共享内存空间时,它们可以通过读写共享内存中的数据来进行通信。

进程可以将数据写入共享内存,其他进程则可以读取这些数据。

这种通信方式称为进程间通信(IPC)。

2. 消息传递:消息传递是一种常用的进程通信方式。

进程可以通过发送和接收消息来进行通信。

常见的消息传递系统包括管道、队列、信箱等。

3. 共享内存:共享内存允许多个进程访问同一块内存空间,通过读写共享内存中的数据来进行通信。

共享内存的实现需要一种同步机制,以避免多个进程同时读写共享内存导致的数据冲突。

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

它通常用于实现互斥锁、条件变量等同步原语,以确保多个进程在访问共享资源时的正确性。

5. 套接字:套接字是一种通用的进程间通信机制,可以在不同主机上的进程之间进行通信。

通过套接字,进程可以发送和接收数据,实现类似于管道和消息传递的通信方式。

总之,进程通信的原理主要是通过共享内存、消息传递、信号量、套接字等方式实现并发进程之间的相互合作和协调,以完成特定的任务。

ros 进程通信原理(一)

ros 进程通信原理(一)

ros 进程通信原理(一)ROS 进程通信1. 介绍ROS(机器人操作系统)是一种用于编写机器人软件的开源框架。

在ROS中,进程通信是实现节点之间通信的重要方式。

本文将从浅入深地介绍ROS进程通信的相关原理。

2. 进程通信概述进程通信是指在一个操作系统中,不同进程之间进行数据或信号的交流。

在ROS中,进程通信用于节点之间传递数据、发送消息以及触发动作。

3. ROS中的进程通信方式发布/订阅模型发布/订阅模型是ROS中最常用的进程通信方式。

一个节点(发布者)将消息发布到一个特定的主题上,另一个或多个节点(订阅者)可以订阅该主题,以接收相应的消息。

服务模型服务模型是一种请求-响应模型,其中一个节点(服务提供者)提供某种服务,另一个或多个节点(服务请求者)可以向服务提供者发送请求,并接收响应。

动作模型动作模型是一种扩展的服务模型,与服务模型不同的是,动作模型可以在服务请求过程中发送多个连续的反馈消息,同时也可以取消请求。

参数服务器参数服务器是在ROS中用于存储和共享数据的一种机制。

节点可以读取和写入参数服务器上的参数,以实现参数共享和传递。

4. 进程通信的实现原理ROS中的进程通信是通过ROS Master来实现的。

ROS Master是一个节点,负责维护整个ROS系统中的节点、主题、服务和参数等信息。

当一个节点启动时,它会向ROS Master注册自己的名称和提供的服务、主题等信息。

其他节点可以通过ROS Master查询并与该节点通信。

在发布/订阅模型中,发布者首先将消息发送给ROS Master,并指定要发布的主题。

然后,订阅者查询ROS Master,找到要订阅的主题,并与发布者建立连接,以接收消息。

在服务模型和动作模型中,请求者首先向ROS Master查询要请求的服务或动作。

ROS Master告诉请求者该服务或动作的提供者信息,请求者可以直接与提供者建立连接。

参数服务器是一个独立的进程,可以由ROS Master维护。

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

无名管道的用法无名管道又被称为pipe,是进程间通信的一种方式。

pipe具有以下特点:●只能用于具有血缘关系的进程之间●半双工的通信模式,具有固定的读端和写端●一种特殊的文件,存在于内存中。

可通过read、write对其操作因为pipe存在于内存中,所以无法像操作普通文件那样通过指定路径来打开文件。

通常的做法是在父进程中创建管道,再创建子进程。

由于子进程继承了父进程打开的文件描述符,所以父子进程就可以通过创建的管道进行通信。

为了在父进程中创建管道,需要先定义一个包含两个元素的整型数组,用来存放管道读端和写端对应的文件描述符。

该数组在创建管道时作为参数传递。

要注意的是,管道是一种半双工方式,即对于进程来说,要么只能读管道,要么只能写管道。

不允许对管道又读又写。

其中数组的第一个元素固定代表管道的读端,第二个元素代表管道的写端。

对于一个进程来说,只会用到其中一个。

若读取管道时没有数据,则进程会被阻塞,直到有数据可读。

写管道时除非管道已满,一般情况下写入操作很快会返回。

这里假设父进程读管道,子进程写管道。

参考代码如下所示:int pfd[2];pid_t pid;if ( pipe(pfd) < 0 ) // 创建管道失败{perror(“fail to create pipe : ”);exit(-1);}if ( (pid=fork()) == -1 ) // 创建子进程失败{perror(“fail to create child process : ”);exit(-1);}else if ( pid == 0 ) // 子进程{close(pfd[0]); // 子进程关闭读端……写管道……}else // 父进程{close(pfd[1]); // 父进程关闭写端……读管道……}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;}使用管道有一些限制:两个进程通过一个管道只能实现单向通信,比如上面的例子,父进程写子进程读,如果有时候也需要子进程写父进程读,就必须另开一个管道。

请读者思考,如果只开一个管道,但是父进程不关闭读端,子进程也不关闭写端,双方都有读端和写端,为什么不能实现双向通信?管道的读写端通过打开的文件描述符来传递,因此要通信的两个进程必须从它们的公共祖先那里继承管道文件描述符。

上面的例子是父进程把文件描述符传给子进程之后父子进程之间通信,也可以父进程fork两次,把文件描述符传给两个子进程,然后两个子进程之间通信,总之需要通过fork传递文件描述符使两个进程都能访问同一管道,它们才能通信。

使用管道需要注意以下4种特殊情况(假设都是阻塞I/O操作,没有设置O_NONBLOCK标志):1. 如果所有指向管道写端的文件描述符都关闭了(管道写端的引用计数等于0),而仍然有进程从管道的读端读数据,那么管道中剩余的数据都被读取后,再次read会返回0,就像读到文件末尾一样。

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

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

在第33 章信号会讲到怎样使SIGPIPE信号不终止进程。

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

管道的这四种特殊情况具有普遍意义。

在第37 章socket编程要讲的TCP socket也具有管道的这些特性。

Linux 下进程间通信机制(二) Pipe和Fifo分类:Linux C 2011-08-23 17:27 40人阅读评论(0) 收藏举报无名管道pipe:view plaincopy to clipboardprint?1.#include<unistd.h>2.#include<string.h>3.#include<stdlib.h>4.#include<stdio.h>5.#include<errno.h>6.#define N 1287.8.int main()9.{10.char buf_w[N];11.char buf_r[N];12.int fd[2];13.int pid;14. pipe(fd); //管道基于文件描述符15. if((pid=fork()) == -1)16. {17. perror("fork");18. exit(-1);19. }20.21. if(pid == 0)22. {23. close(fd[0]);24. while(1)25. {26. while(fgets(buf_w, N, stdin) != NULL)27. //注意fgets函数的用法,谨慎处理字符串中的'\0'和'\n'28. {29. printf("read from child\n");30. buf_w[strlen(buf_w)-1] = 0;//去掉字符串中的'\n'31. write(fd[1], buf_w ,strlen(buf_w));32. }33. }34. }35. else36. {37. close(fd[1]);38.int n;39. while(1)40. {41. if((n = read(fd[0], buf_r, N)) >0)42. {43. buf_r[n] ='\n';44. write(1, buf_r, n+1);45. printf("write form parent%d\n",n);46. }47. sleep(3);48. }49. }50. exit(0);51.}1.//createfifo.c2.3.#include<stdio.h>4.#include<fcntl.h>5.#include<unistd.h>6.#include<sys/types.h>7.#include<error.h>8.#include<stat.h>9.#include<stdlib.h>10.11.int main()12.{13. if(mkfifo("fifo.demo", 0666) == -1)14. {15. perror("mkfifo");16. exit(-1);17. }18. return 0;19.}20.21.22.//writefifo.c23.//先执行writefifo,不执行readfifo,则阻塞在open函数(可以增加参数,实现非阻塞)1.#include<unistd.h>2.#include<fcntl.h>3.#include<string.h>4.#include<stdlib.h>5.#include<stdio.h>6.#include<error.h>7.#define N 648.9.int main()10.{11.int fd;12.char buf[N];13. if((fd=open("fifo.demo", O_WRONLY)) == -1)14. {15. perror("open fifo.demo");16. exit(-1);17. }18.19. while(1)20. {21. if(fgets(buf, N, stdin) != NULL)22. {23. write(fd, buf, strlen(buf));24. if(strncmp(buf,"exit", 4) == 0)//比较前四个字符,buf第五个字符是'\n'25. {26. close(fd);27. exit(1);28. }29. }30. }31.}32.33.34.35.//readfifo.c36.//先执行readfifo,不执行writefifo,则阻塞在open函数(可以增加参数,实现非阻塞)37.38.39.#include<fcntl.h>40.#include<stdio.h>41.#include<unistd.h>42.#include<stdlib.h>43.44.45.#define N 6446.47.int main()48.{49.int fd;50.char buf[N];51.int n;52.53. if((fd=open("fifo.demo", O_RDONLY))== -1)54. {55. perror("open fifo.demo");56. exit(-1);57. }58.59. while(1)60. {61. if((n = read(fd, buf, N)) >= 0)62. {63. if(n == 0)64. {65. exit(1);66. }67. write(1, buf, n);//读多少,写多少68. }69. }70.}1.//readfile.c2./*读文件,写管道*/3.//先调用mkfifo命令创建一个fifo文件4.5.6.#include<unistd.h>7.#include<sys/types.h>8.#include<sys/stat.h>9.#include<error.h>10.#include<stdio.h>11.#include<stdlib.h>12.#include<fcntl.h>13.14.15.#define N 12816.int main(int argc, char *argv[])17.{18.int n;19.int fd;20.int filefd;21.char buf[N];22.23. //24. if(argc != 2)25. {26. fprintf(stderr,"usage:%s <sourcefile>\n", argv[0]);27. perror("");28. exit(-1);29. }30.31.32. //open source file33. if((filefd=open(argv[1],O_RDONLY)) ==-1)34. {35. perror("open filefd");36. exit(-1);37. }38.39. /*create fifo40. if(mkfifo("copyfifo",0666) ==-1)41. {42. perror("mkfifo");43. exit(-1);44. }*/45.46. //open fifo47. if((fd = open("copyfifo",O_WRONLY))==-1)48. {49. perror("open copyfifo");50. exit(-1);51. }52.53.54. while((n=read(filefd, buf, N)) >=0)55. {56. if(n == 0)57. {58. close(fd);59. close(filefd);60. }61. else62. {63. write(fd, buf, n);//注意读多少,写多少64. }65.66. }67.68.}69.70.//writefile.c71./*读管道,写文件*/72.#include<unistd.h>73.#include<sys/types.h>74.#include<sys/stat.h>75.#include<error.h>76.#include<stdio.h>77.#include<stdlib.h>78.#include<fcntl.h>79.80.81.#define N 12882.int main(int argc, char *argv[])83.{84.int n;85.int fd;86.int filefd;87.char buf[N];88.89. //90. if(argc != 2)91. {92. fprintf(stderr,"usage:%s <sourcefile>\n", argv[0]);93. perror("");94. exit(-1);95. }96.97.98. //open source file99. if((filefd=open(argv[1],O_WRONLY|O_CREAT|O_TRUNC,0666)) ==-1) 100. {101. perror("open filefd");102. exit(-1);103. }104.105. //open fifo106. if((fd = open("copyfifo",O_RDONLY))==-1)107. {108. perror("open copyfifo");109. exit(-1);110. }111.112.113. while((n=read(fd, buf, N)) >=0)114. //写端关闭,管道中没有文件时返回0,利用返回值0判断写端是否存在,不返回零没有数据则阻塞115. {116. if(n == 0)117. {118. close(fd);119. close(filefd);120. exit(1);121. }122. else123. {124. write(filefd, buf, n);125. }126.127. }128.}Linux 下进程间通信机制(三) 信号Signal分类:Linux C 2011-08-24 11:58 58人阅读评论(0) 收藏举报信号的响应函数void(*signal(int signum, void(*handler)(int)))(int);解释:signum:指定的信号(系统支持的)handler:可能的取值有三种SIG_IGN(忽略该信号) SIG_DFL(系统默认操作)自定义的处理函数指针成功:返回上一次设置的函数指针失败:-1demo1:view plaincopy to clipboardprint?1.#include<stdio.h>2.#include<unistd.h>3.#include<signal.h>4.5.typedef void(*pFunc)(int);6.7.void myhandler1(int signo)8.{9. printf("myhander1 signo:%d\n", signo);10.}11.12.13.void myhandler2(int signo)14.{15. printf("myhander2 signo:%d\n", signo);16.}17.18.int main()19.{20. pFunc hander1, hander2;21.22. hander1 = signal(14, myhandler2);//第一次设置响应函数23. hander2 = signal(14, myhandler1); //设置信号响应函数,返回上一次设置的响应函数指针,但不会返回默认。

相关文档
最新文档