Linux系统编程实验六：进程间通信
实验六：进程间通信
●实验目的：
学会进程间通信方式：无名管道，有名管道，信号，消息队列，
●实验要求：
（一）在父进程中创建一无名管道，并创建子进程来读该管道，父进程来写该管道（二）在进程中为SIGBUS注册处理函数，并向该进程发送SIGBUS信号
（三）创建一消息队列，实现向队列中存放数据和读取数据
●实验器材：
软件：安装了Linux的vmware虚拟机
硬件：PC机一台
●实验步骤：
（一）无名管道的使用
1、编写实验代码pipe_rw.c
#include
#include
#include
#include
#include
#include
int main()
{
int pipe_fd[2];//管道返回读写文件描述符
pid_t pid;
char buf_r[100];
char* p_wbuf;
int r_num;
memset(buf_r,0,sizeof(buf_r));//将buf_r初始化
char str1[]=”parent write1 “holle””;
char str2[]=”parent write2 “pipe”\n”;
r_num=30;
/*创建管道*/
if(pipe(pipe_fd)<0)
{
printf("pipe create error\n");
return -1;
}
/*创建子进程*/
if((pid=fork())==0) //子进程执行代码
{
//1、子进程先关闭了管道的写端
close(pipe_fd[1]);
//2、让父进程先运行，这样父进程先写子进程才有内容读sleep(2);
//3、读取管道的读端，并输出数据
if(read(pipe_fd[0],buf_r, r_num)<0)
{
printf(“read error!”);
exit(-1);
}
printf(“%s\n”,buf_r);
//4、关闭管道的读端，并退出
close(pipe_fd[1]);
}
else if(pid>0) //父进程执行代码
{
//1、父进程先关闭了管道的读端
close(pipe_fd[0]);
//2、向管道写入字符串数据
p_wbuf=&str1;
write(pipe_fd[1],p_wbuf,sizof(p_wbuf));
p_wbuf=&str2;
write(pipe_fd[1],p_wbuf,sizof(p_wbuf));
//3、关闭写端，并等待子进程结束后退出
close(pipe_fd[1]);
}
return 0;
}
/***********************
#include
#include
#include
#include
#include
#include
int main()
{
int pipe_fd[2];//管道返回读写文件描述符
pid_t pid;
char buf_r[100];
char* p_wbuf;
int r_num;
memset(buf_r,0,sizeof(buf_r));//将buf_r初始化
char str1[]="holle";
char str2[]="pipe";
r_num=10;
/*创建管道*/
if(pipe(pipe_fd)<0)
{
printf("pipe create error\n");
return -1;
}
/*创建子进程*/
if((pid=fork())==0) //子进程执行代码
{
close(pipe_fd[1]);//1、子进程先关闭了管道的写端
//2、让父进程先运行，这样父进程先写子进程才有内容读
//3、读取管道的读端，并输出数据
if(read(pipe_fd[0],buf_r, r_num)<0)
{
printf("read1 error!");
exit(-1);
}
printf("\nparent write1 %s!",buf_r);
sleep(1);
if(read(pipe_fd[0],buf_r, r_num)<0)
{
printf("read2 error!");
exit(-1);
}
printf("\nparent write2 %s!",buf_r);
close(pipe_fd[1]);//4、关闭管道的读端，并退出
exit(1);
//printf("child error!");
}
else if(pid>0) //父进程执行代码
{
close(pipe_fd[0]);//1、父进程先关闭了管道的读端
p_wbuf=str1;//2、向管道写入字符串数据
write(pipe_fd[1],p_wbuf,sizeof(str1));
sleep(1);
p_wbuf=str2;
write(pipe_fd[1],p_wbuf,sizeof(str2));
close(pipe_fd[1]);//3、关闭写端，并等待子进程结束后退出
exit(1);
//printf("father error!");
}
return 0;
}
**************************/
2、编译应用程序pipe_rw.c
3、运行应用程序
子进程先睡两秒让父进程先运行，父进程分两次写入“hello”和“pipe”，然后阻塞等待子进程退出，子进程醒来后读出管道里的内容并打印到屏幕上再退出，父进程捕获到子进程退出后也退出
4、由于fork函数让子进程完整地拷贝了父进程的整个地址空间，所以父子进程都有管道的读端和写端。我们往往希望父子进程中的一个进程写一个进程读，那么写的进程最后关掉读端，读的进程最好关闭掉写端
（二）信号处理
1、编写实验代码sig_bus.c
#include
#include
#include
//1、自定义信号处理函数，处理SIGBUS信号，打印捕捉到信号即可static void signal_handler(int signo)
{
if(signo ==SIGBUS)
printf(“\n I have get SIGBUS”);
exit(EXIT_FAILURE);
}
int main()
{
printf("Waiting for signal SIGBUS \n ");
//2、注册信号处理函数
if(signal(SIGBUS,signal_handler)==SIG_ERR)
{
fprintf(stderr,”cannot handle SIGBUS\n”);
exit(EXIT_FAILURE);
}
pause();//将进程挂起直到捕捉到信号为止
exit(0);
return 0;
}
/********************************
#include
#include
#include
#include
//1、自定义信号处理函数，处理SIGBUS信号，打印捕捉到信号即可static void signal_handler(int signo)
{
if(signo ==SIGBUS)
printf("I have get SIGBUS");
exit(EXIT_FAILURE);
}
int main()
{
printf("Waiting for signal SIGBUS \n ");
//2、注册信号处理函数
if(signal(SIGBUS,signal_handler)==SIG_ERR)
{
fprintf(stderr,"cannot handle SIGBUS\n");
exit(EXIT_FAILURE);
}
pause();//将进程挂起直到捕捉到信号为止
exit(0);
return 0;
}
***************************/
用signal系统调用为SIGBUS信号注册信号处理函数my_func，然后将进程挂起等待SIGBUS信号。所以需要向该进程发送SIGBUS信号才会执行自定义的信号处理函数
2、编译应用程序sig_bus.c
3、运行应用程序
先先一个终端中运行sig_bus，会看到进程挂起，等待信号
然后在另一个终端中，查找到运行sig_bus这个产生的进程号，用kill命令发送SIGBUS信号给这个进程
我们可以看到前面挂起的进程在接收到这个信号后的处理
用自定义信号处理函数my_func来处理，所以打印了I have get SIGBUS这样一句话
上机报告要求：
1、总结pipe()，signal()的函数定义原型，返回值和参数的意义
表头文件：#include
定义函数：int pipe(int filedes[2]);
函数说明（参数）：pipe()会建立管道，并将文件描述词由参数filedes数组返回。
filedes[0]为管道里的读取端，filedes[1]则为管道的写入端。
返回值：若成功则返回零，否则返回-1，错误原因存于errno中。
阻塞问题：当管道中的数据被读取后，管道为空。一个随后的read()调用将默认的被阻塞，等待某些数据写入。
功能：管道是一种把两个进程之间的标准输入和标准输出连接起来的机制，从而提供一种让多个进程间通信的方法，当进程创建管道时，每次都需要提供两个文件描述符来操作管道。其中一个对管道进行写操作，另一个对管道进行读操作。对管道的读写与一般的IO系统函数一致，使用write()函数写入数据，使用read()读出数据。
表头文件： #include
功能：设置某一信号的对应动作
函数原型：void (*signal(int signum,void(* handler)(int)))(int);
或者：typedef void(*sig_t) ( int ); sig_t signal(int signum,sig_t handler);
可看成是signal()函数（它自己是带有两个参数，一个为整型，一个为函数指针的函数），而这个signal()函数的返回值也为一个函数指针，这个函数指针指向一个带整型参数，并且返回值为void的一个函数。
参数说明：第一个参数signum指明了所要处理的信号类型，它可以取除了SIGKILL和SIGSTOP外的任何一种信号。
第二个参数handler描述了与信号关联的动作，它可以取以下三种值：
（1）一个返回值为正数的函数地址
此函数必须在signal()被调用前申明，handler中为这个函数的名字。当接收到一个类型为sig的信号时，就执行handler 所指定的函数。这个函数应有如下形式的定义：
intfunc(int sig); sig是传递给它的唯一参数。执行了signal()调用后，进程只要接收到类型为sig的信号，不管其正在执行程序的哪一部分，就立即执行func()函数。当func()函数执行结束后，控制权返回进程被中断的那一点继续执行。
（2）SIGIGN
这个符号表示忽略该信号，执行了相应的signal()调用后，进程会忽略类型为sig的信号。
（3）SIGDFL
这个符号表示恢复系统对信号的默认处理。
函数说明：signal()会依参数signum 指定的信号编号来设置该信号的处理函数。当指定的信
号到达时就会跳转到参数handler指定的函数执行。当一个信号的信号处理函数执行时，如果进程又接收到了该信号，该信号会自动被储存而不会中断信号处理函数的执行，直到信号处理函数执行完毕再重新调用相应的处理函数。但是如果在信号处理函数执行时进程收到了其它类型的信号，该函数的执行就会被中断。
返回值：返回先前的信号处理函数指针，如果有错误则返回SIG_ERR(-1)。
附加说明：在信号发生跳转到自定的handler处理函数执行后，系统会自动将此处理函数换回原来系统预设的处理方式，如果要改变此操作请改用sigaction()。
下面的情况可以产生Signal：
1. 按下CTRL+C产生SIGINT
2. 硬件中断，如除0，非法内存访问（SIGSEV）等等
3. Kill函数可以对进程发送Signal
4. Kill命令。实际上是对Kill函数的一个包装
5. 软件中断。如当Alarm Clock超时（SIGURG），当Reader中止之后又向管道写数据
（SIGPIPE），等等
命名管道FIFO
功能：管道最大的劣势就是没有名字，只能用于有一个共同祖先进程的各个进程之间。FIFO 代表先进先出，单它是一个单向数据流，也就是半双工，和管道不同的是：每个FIFO 都有一个路径与之关联，从而允许无亲缘关系的进程访问。
头文件：#include
#include
函数定义原型：int mkfifo(const char *pathname, mode_t mode);
参数：这里pathname是路径名,mode是sys/stat.h里面定义的创建文件的权限.
2、利用有名管道FIFO实现类似第一个实验的功能，一个程序fifo_read.c写数据”Hi Linux”，另一个程序fifo_write.c读数据并打印出来。
//fifo.read.c
#include
#include
#include
#include
#include
#include
#include
#include
//#define FIFO "fifo"
int main()
{
int fdr,fd;
char buf_r[]="Hi Linux\n";
fd=mkfifo("fifo.txt",O_CREAT|O_RDWR|0666);
if(fd<0)
{printf("fifo creat error(R)!\n");
exit(-1);
}
fdr=open("fifo.txt",O_WRONL Y|O_CREA T,0666); if(fdr<0)
{
printf("open error!");
exit(-1);
}
if(write(fdr,buf_r,sizeof(buf_r))<0)
{
printf("write error");
exit(-1);
}
close(fdr);
close(fd);
return 0;
}
#include
#include
#include
#include
#include
#include
#include
#include
//#define FIFO "fifo"
int main()
{
int fdw,fd;
char buf[100];
memset(buf,0,sizeof(buf));
fdw=open("fifo.txt",O_RDONL Y);
if(fdw<0)
{
printf("open error(W)!");
exit(-1);
}
//sleep(2);
if(read(fdw,buf,100)<0)
{
printf("read error(W)");
exit(-1);
}
printf("\n%s",buf);
close(fdw);
return 0;
}
Linux进程间通信(2)实验报告
实验六：Linux进程间通信（2）（4课时） 实验目的： 理解进程通信原理；掌握进程中信号量、共享内存、消息队列相关的函数的使用。实验原理： Linux下进程通信相关函数除上次实验所用的几个还有： 信号量 信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是前一节的共享内存方式的进程间通信。要调用的第一个函数是semget，用以获得一个信号量ID。 int semget(key_t key, int nsems, int flag); key是IPC结构的关键字，flag将来决定是创建新的信号量集合，还是引用一个现有的信号量集合。nsems是该集合中的信号量数。如果是创建新集合（一般在服务器中），则必须指定nsems；如果是引用一个现有的信号量集合（一般在客户机中）则将nsems指定为0。 semctl函数用来对信号量进行操作。 int semctl(int semid, int semnum, int cmd, union semun arg); 不同的操作是通过cmd参数来实现的，在头文件sem.h中定义了7种不同的操作，实际编程时可以参照使用。 semop函数自动执行信号量集合上的操作数组。 int semop(int semid, struct sembuf semoparray[], size_t nops); semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。 ftok原型如下： key_t ftok( char * fname, int id ) fname就是指定的文件名(该文件必须是存在而且可以访问的)，id是子序号，虽然为int，但是只有8个比特被使用(0-255)。 当成功执行的时候，一个key_t值将会被返回，否则-1 被返回。 共享内存 共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。首先要用的函数是shmget，它获得一个共享存储标识符。 #include
线程实现邮箱通信-实验报告
进程通信实验报告 一、实验名称：进程通信 二、实验目的：掌握用邮箱方式进行进程通信的方法，并通过设计实现简单邮箱理解进程通信中的同步问题以及解决该问题的方法。 三、实验原理：邮箱机制类似于日常使用的信箱。对于用户而言使用起来比较方便，用户只需使用send （）向对方邮箱发邮件 receive （）从自己邮箱取邮件， send （）和 receive （）的内部操作用户无需关心。因为邮箱在内存中实现，其空间有大小限制。其实send （）和 receive （）的内部实现主要还是要解决生产者与消费者问题。 四、实验内容：进程通信的邮箱方式由操作系统提供形如send （）和receive （）的系统调用来支持，本实验要求学生首先查找资料了解所选用操作系统平台上用于进程通信的系统调用具体形式，然后使用该系统调用编写程序进行进程间的通信，要求程序运行结果可以直观地体现在界面上。在此基础上查找所选用操作系统平台上支持信号量机制的系统调用具体形式，运用生产者与消费者模型设计实现一个简单的信箱，该信箱需要有创建、发信、收信、撤销等函数，至少能够支持两个进程互相交换信息，比较自己实现的信箱与操作系统本身提供的信箱，分析两者之间存在的异同。 五、背景知识介绍： 1、sembuf 数据结构 struct sembuf { unsigned short int sem_num; //semaphore number short int sem_op; //semaphore operation short int sem_flg; //operation flag }; sem_num ：操作信号在信号集中的编号，第一个信号的编号是0。 进程A 进程B 信箱A 信箱B Send() Send() receive() receive()
Linux系统编程实验六进程间通信
实验六：进程间通信 实验目的： 学会进程间通信方式：无名管道，有名管道，信号，消息队列， 实验要求： （一）在父进程中创建一无名管道，并创建子进程来读该管道，父进程来写该管道（二）在进程中为SIGBUS注册处理函数，并向该进程发送SIGBUS信号（三）创建一消息队列，实现向队列中存放数据和读取数据 实验器材： 软件：安装了Linux的vmware虚拟机 硬件：PC机一台 实验步骤： （一）无名管道的使用 1、编写实验代码pipe_rw.c #include
//1、子进程先关闭了管道的写端 close(pipe_fd[1]); //2、让父进程先运行，这样父进程先写子进程才有内容读sleep(2); //3、读取管道的读端，并输出数据 if(read(pipe_fd[0],buf_r, r_num)<0) { printf(“read error!”); exit(-1); } printf(“%s\n”,buf_r); //4、关闭管道的读端，并退出 close(pipe_fd[1]); } else if(pid>0) //父进程执行代码 { //1、父进程先关闭了管道的读端 close(pipe_fd[0]); //2、向管道写入字符串数据 p_wbuf=&str1; write(pipe_fd[1],p_wbuf,sizof(p_wbuf)); p_wbuf=&str2; write(pipe_fd[1],p_wbuf,sizof(p_wbuf)); //3、关闭写端，并等待子进程结束后退出 close(pipe_fd[1]); } return 0; } /*********************** #include
进程管理实验报告文档
实验一进程管理 1．实验目的： （1）加深对进程概念的理解，明确进程和程序的区别； （2）进一步认识并发执行的实质； （3）分析进程争用资源的现象，学习解决进程互斥的方法； （4）了解Linux系统中进程通信的基本原理。 2．实验预备内容 （1）阅读Linux的源码文件，加深对进程管理概念的理解； （2）阅读Linux的fork()源码文件，分析进程的创建过程。 3．实验内容 （1）进程的创建： 编写一段程序，使用系统调用fork() 创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果，并分析原因。 源代码: #include <> #include <> #include
int p1,p2; p1=fork(); ockf()函数是将文件区域用作信号量（监视锁），或控制对锁定进程的访问（强制模式记录锁定）。试图访问已锁定资源的其他进程将返回错误或进入休态，直到资源解除锁定为止。而上面三个进程，不存在要同时进入同一组共享变量的临界区域的现象，因此输出和原来相同。 （3） a) 编写一段程序，使其实现进程的软中断通信。 要求：使用系统调用fork() 创建两个子进程，再用系统调用signal() 让父进程捕捉键盘上来的中断信号（即按DEL键）；当捕捉到中断信号后，父进程用系统调用Kill() 向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止： Child Process 1 is killed by Parent! Child Process 2 is killed by Parent! 父进程等待两个子进程终止后，输出如下的信息后终止： Parent Process is killed!
实验6 进程及进程间的通信之共享内存
实验6 进程及进程间的通信 ●实验目的： 1、理解进程的概念 2、掌握进程复制函数fork的用法 3、掌握替换进程映像exec函数族 4、掌握进程间的通信机制，包括：有名管道、无名管道、信 号、共享内存、信号量和消息队列 ●实验要求： 熟练使用该节所介绍fork函数、exec函数族、以及进程间通信的相关函数。 ●实验器材： 软件： 1.安装了Ubunt的vmware虚拟机 硬件：PC机一台 ●实验步骤： 1、用进程相关API 函数编程一个程序，使之产生一个进程 扇：父进程产生一系列子进程，每个子进程打印自己的PID 然后退出。要求父进程最后打印PID。 进程扇process_fan.c参考代码如下：
2、用进程相关API 函数编写一个程序，使之产生一个进程 链：父进程派生一个子进程后，然后打印出自己的PID，然后退出，该子进程继续派生子进程，然后打印PID，然后退出，以此类推。
要求：1) 实现一个父进程要比子进程先打印PID 的版本。（即 打印的PID 一般是递增的） 2 )实现一个子进程要比父进程先打印PID 的版本。（即打印的PID 一般是递减的） 进程链1,process_chain1.c的参考代码如下：
进程链2，process_chain2.c的参考代码如下：
3、编写程序execl.c，实现父进程打印自己的pid号,子进程调用 execl函数，用可执行程序file_creat替换本进程。注意命令行参数。 参考代码如下： /*execl.c*/ #include
进程间通信实验报告
进程间通信实验报告 班级：10网工三班学生姓名：谢昊天学号：1215134046 实验目的和要求： Linux系统的进程通信机构 (IPC) 允许在任意进程间大批量地交换数据。本实验的目的是了解和熟悉Linux支持的消息通讯机制及信息量机制。 实验内容与分析设计： （1）消息的创建，发送和接收。 ①使用系统调用msgget (), msgsnd (), msgrev (), 及msgctl () 编制一长度为1k 的消息的发送和接收程序。 ②观察上面的程序，说明控制消息队列系统调用msgctl () 在此起什么作用？ （2）共享存储区的创建、附接和段接。 使用系统调用shmget(),shmat(),sgmdt(),shmctl(),编制一个与上述功能相同的程序。（3）比较上述（1），（2）两种消息通信机制中数据传输的时间。 实验步骤与调试过程： 1.消息的创建，发送和接收： (1)先后通过fork( )两个子进程，SERVER和CLIENT进行通信。 (2)在SERVER端建立一个Key为75的消息队列，等待其他进程发来的消息。当遇到类型为1的消息，则作为结束信号，取消该队列，并退出SERVER 。SERVER每接收到一个消息后显示一句“(server)received”。 (3)CLIENT端使用Key为75的消息队列，先后发送类型从10到1的消息，然后退出。最后的一个消息，既是 SERVER端需要的结束信号。CLIENT每发送一条消息后显示一句“(client)sent”。 (4)父进程在 SERVER和 CLIENT均退出后结束。 2.共享存储区的创建,附接和断接： (1)先后通过fork( )两个子进程，SERVER和CLIENT进行通信。 (2)SERVER端建立一个KEY为75的共享区,并将第一个字节置为-1。作为数据空的标志.等待其他进程发来的消息.当该字节的值发生变化时,表示收到了该消息,进行处理.然后再次把它的值设为-1.如果遇到的值为0,则视为结束信号,取消该队列,并退出SERVER.SERVER 每接收到一次数据后显示”(server)received”. (3)CLIENT端建立一个为75的共享区,当共享取得第一个字节为-1时, Server端空闲,可发送请求. CLIENT 随即填入9到0.期间等待Server端再次空闲.进行完这些操作后, CLIENT退出. CLIENT每发送一次数据后显示”(client)sent”. (4)父进程在SERVER和CLIENT均退出后结束。 实验结果： 1．消息的创建，发送和接收： 由 Client 发送两条消息，然后Server接收一条消息。此后Client Server交替发送和接收消息。最后一次接收两条消息。Client 和Server 分别发送和接收了10条消息。message 的传送和控制并不保证完全同步,当一个程序不再激活状态的时候,它完全可能继续睡眠,造成上面现象。在多次send message 后才 receive message.这一点有助于理解消息转送的实现机理。
Linux进程通信实验报告
Linux进程通信实验报告 一、实验目的和要求 1.进一步了解对进程控制的系统调用方法。 2.通过进程通信设计达到了解UNIX或Linux系统中进程通信的基本原理。 二、实验内容和原理 1.实验编程，编写程序实现进程的管道通信(设定程序名为pipe.c)。使 用系统调用pipe()建立一条管道线。而父进程从则从管道中读出来自 于两个子进程的信息，显示在屏幕上。要求父进程先接受子进程P1 发来的消息，然后再接受子进程P2发来的消息。 2.可选实验，编制一段程序，使其实现进程的软中断通信(设定程序名为 softint.c)。使用系统调用fork()创建两个子进程，再用系统调用 signal()让父进程捕捉键盘上来的中断信号(即按Del键)，当父进程 接受这两个软中断的其中一个后，父进程用系统调用kill()向两个子 进程分别发送整数值为16和17的软中断信号，子进程获得对应软中 断信号后分别输出相应信息后终止。 三、实验环境 一台安装了Red Hat Linux 9操作系统的计算机。 四、实验操作方法和步骤 进入Linux操作系统，利用vi编辑器将程序源代码输入并保存好，然后 打开终端对程序进行编译运行。 五、实验中遇到的问题及解决 六、实验结果及分析 基本实验 可选实验
七、源代码 Pipe.c #include"stdio.h" #include"unistd.h" main(){ int i,j,fd[2]; char S[100]; pipe(fd); if(i=fork==0){ sprintf(S,"child process 1 is sending a message \n"); write(fd[1],S,50); sleep(3); return; } if(j=fork()==0){ sprintf(S,"child process 2 is sending a message \n"); write(fd[1],S,50); sleep(3); return;
linux进程间通讯的几种方式的特点和优缺点
1. # 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。 # 有名管道(named pipe) ：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。 # 信号量( semophore ) ：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。 # 消息队列( message queue ) ：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。 # 信号( sinal ) ：信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。#共享内存( shared memory)：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的IPC方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。 # 套接字( socket ) ：套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。 管道的主要局限性正体现在它的特点上： 只支持单向数据流； 只能用于具有亲缘关系的进程之间； 没有名字； 管道的缓冲区是有限的（管道制存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；管道所传送的是无格式字节流，这就要求管道的读出方和写入方必须事先约定好数据的格式，比如多少字节算作一个消息（或命令、或记录）等等； 2. 用于进程间通讯(IPC)的四种不同技术: 1. 消息传递(管道,FIFO,posix和system v消息队列) 2. 同步(互斥锁,条件变量,读写锁,文件和记录锁,Posix和System V信号灯) 3. 共享内存区(匿名共享内存区,有名Posix共享内存区,有名System V共享内存区) 4. 过程调用(Solaris门,Sun RPC) 消息队列和过程调用往往单独使用,也就是说它们通常提供了自己的同步机制.相反,共享内存区
实验三 进程间通信
实验三进程间通信（2学时） 一、实验目的 (1)了解什么是信号。 (2)熟悉LINUX系统中进程之间软中断通信的基本原理。 (3)熟悉LINUX支持的管道通信方式。 二、实验内容 （1）编写一段程序，使其现实进程的软中断通信。 即：使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按 ctrl+c 键）；当捕捉到中断信号后，父进程用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后，分别输出下列信息后终止： Child Process11 is killed by Parent! Child Process12 is killed by Parent! 父进程等待两个子进程终止后，输出如下的信息后终止 Parent Process is killed! 要求：运行以下参考程序并分析结果。 <参考程序> #include
signal(SIGALRM,alarming);/*接受SIGALRM*/ waiting(); kill(p1,16); /*向p1发软中断信号16*/ kill(p2,17); /*向p2发软中断信号17*/ wait(0); /*同步*/ wait(0); printf("parent process is killed!\n"); exit(0); //会暂时停止目前进程的执行，直到有信号来到或子进程结束。 } else { wait_mark=1; signal(17,stop); signal(SIGINT,SIG_IGN); /*忽略 ^c信号*/ while (wait_mark!=0); lockf(1,1,0); printf("child process2 is killed by parent!\n"); lockf(1,0,0); exit(0); } } else { wait_mark=1; signal(16,stop); signal(SIGINT,SIG_IGN); /*忽略^c信号*/ while (wait_mark!=0); lockf(1,1,0); printf("child process1 is killed by parent!\n"); lockf(1,0,0); exit(0); } } void waiting() { sleep(5); if (wait_mark!=0) kill(getpid(),SIGALRM); } void alarming()
进程同步实验报告
实验三进程的同步 一、实验目的 1、了解进程同步和互斥的概念及实现方法； 2、更深一步的了解fork()的系统调用方式。 二、实验内容 1、预习操作系统进程同步的概念及实现方法。 2、编写一段源程序，用系统调用fork()创建两个子进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。程序的输出是什么？分析原因。 3、阅读模拟火车站售票系统和实现进程的管道通信源代码，查阅有关进程创建、进程互斥、进程同步的系统功能调用或API，简要解释例程中用到的系统功能或API的用法，并编辑、编译、运行程序，记录程序的运行结果，尝试给出合理的解释。 4、（选做）修改问题2的代码，使得父子按顺序显示字符“a”；“b”、“c”编辑、编译、运行。记录程序运行结果。 三、设计思想 1、程序框架 （1）创建两个子进程：（2）售票系统：
（3）管道通信： 先创建子进程，然后对内容加锁，将输出语句存入缓存，并让子进程自己进入睡眠，等待别的进程将其唤醒，最后解锁；第二个子进程也执行这样的过程。父进程等待子进程后读内容并输出。 （4）修改程序（1）：在子进程的输出语句前加上sleep()语句，即等待父进程执行完以后再输出。 2、用到的文件系统调用函数 （1）创建两个子进程：fork() （2）售票系统：DWORD WINAPI Fun1Proc(LPVOID lpPartameter); CreateThread(NULL,0,Fun1Proc,NULL,0,NULL); CloseHandle(hThread1); (HANDLE)CreateMutex(NULL,FALSE,NULL); Sleep(4000)（sleep调用进程进入睡眠状态(封锁), 直到被唤醒）; WaitForSingleObject(hMutex,INFINITE); ReleaseMutex(hMutex); （3）管道通信：pipe(fd)，fd: int fd[2]，其中: fd[0] 、fd[1]文件描述符（读、写）; lockf( fd，function，byte)（fd: 文件描述符；function: 1: 锁定 0:解锁；byte: 锁定的字节数，0: 从当前位置到文件尾）; write(fd，buf，byte)、read(fd，buf，byte) （fd: 文件描述符；buf : 信息传送的源（目标）地址；byte: 传送的字节数）; sleep(5); exit(0); read(fd[0]，s，50) （4）修改程序（1）：fork(); sleep(); 四、调试过程 1、测试数据设计 （1）创建两个子进程：
操作系统进程创建及通信实验报告
武汉工程大学计算机科学与工程学院 《操作系统》实验报告[Ⅰ]
一、实验目的 创建进程，实现进程消息通信和共享内存通信，了解进程的创建、退出和获取进程信。了解什么是映像文件、管道通信及其作用，掌握通过内存映像文件和管道技术实现进程通信。 二、实验内容 本例用三种方法实现进程通信，仅用于示例目的，没有进行功能优化。 1、创建进程A和B后，在进程A中输入一些字符，点“利用 SendMessage发送消息”按钮可将消息发到进程B。 2、在进程A中输入一些字符，点“写数据到内存映像文件”按钮， 然后在进程B中点“从内存映像文件读数据”按钮可收到消息。其中在点“写数据到内存映像文件”时，要求创建映像文件，B进程在印象文件中读取数据。 3、先在进程B中点“创建管道并接收数据”按钮，然后在进程A 中输入一些字符，点“写数据到管道文件”按钮可将消息发到进程B。管道是连接读/写进程使他们进行通信的一个共享文件，目的是更好地实现进程间的通信。 三、实验思想 这次试验最主要的内容和核心思想就是学会创建进程并实现进程间的简单通信、创建映像文件和创建管道文件来通信，后两者是实现进程通信的高级通信机制中的两种。. 创建一个程序A和程序B，其中程序A和B各有一个主窗体，A主窗体上要求可以实现创建进程B（即调用函数B）、结束进程B、关闭进程A、向进程B发送数据、创建映像文件、创建管道文件等功能，进程B要求有从映像文件读取数据、创建管道并接收数据、结束进程B功能。最终让A、B进程相互通信。
四、设计分析： 首先设得设计A、B两个程序的操作界面，然后编写各个功能模块。对于A 程序窗体，在“利用SendMessage发送消息”按钮的消息响应函数中，主要是利用Windows API函数CWnd::FindWindow来找到接收消息的窗体，即进程B，找到进程B后，利用这个函数返回的窗体指针的SendMessage函数来发送消息。在“写数据到内存印象文件”按钮的消息响应函数中，主要是利用函数CreateFileMapping来创建一个印象文件，这个函数返回的是这个印象文件的句柄，然后将这个句柄和要发送的消息字符串传递到函数sprintf中，就可以所要发送的消息写入印象文件，在B程序窗体中有个“从内存印象文件读数据”按钮，在这个按钮的消息响应函数中读取父进程所创建的印象文件中的数据就可以实现通信了。在B程序窗体按钮“写数据到管道文件”的消息响应函数中，不能直接将要发送的消息发送到管道文件，因为管道必须先由子进程通过函数CreateNamedPipe创建，只有待子进程创建好管道后父进程才能根据管道创建管道文件，将消息写入管道文件并及时发送给子进程。而且这个管道只能使用一次，即每次发送完消息后那个管道不能在使用了，必须再由子进程创建一个管道，A 进程才能再次创建管道文件并向其中写入消息。这个程序也不一定要MFC实现，还可以用其他的技术和语言实现，比如说Java、VB等，外表构架可以不一样，但核心技术都是一样的，只是不同的调用形式和调用方法，比如说在VB中，实现进程间的一般通信就是使用动态数据交换ＤＤＥ，实现起来就比较简单，但是要创建映像文件和管道文件就比较繁琐，可以根据不同的需求采用不同的语言。 五、程序部分源代码： 1.“利用SendMessage发送消息”按钮中的主要代码 //找到接收消息的窗口(窗口名为Receiver) CString str="进程B"; CWnd *pWnd=CWnd::FindWindow(NULL,str); if(pWnd) { COPYDATASTRUCT buf; char * s=new char[m_Msg1.GetLength()]; //m_Msg1为CString类型的变量 s=m_Msg1.GetBuffer(0);
实验4-进程间通信―共享存储区的创建、附接和断接
操作系统实验报告 课程名称：操作系统 开课学期： 班级： 指导老师： 实验题目：共享存储区的创建、附接和断接学号： 姓名： 提交时间：
一、实验目的和要求 了解和熟悉共享存储机制 二、实验内容 编制一长度为1k的共享存储区发送和接收的程序。 程序设计 （1）为了便于操作和观察结果，用一个程序作为“引子”，先后fork()两个子进程，SERVER和CLIENT,进行通信。 （2）SERVER端建立一个key为75的共享区，并将第一个字节设置为-1,。作为数据空的标志。等待其他进程发来的消息。当字节的值发生变化时，表示收到了信息，进行处理。然后再次把它的值设为-1。如果遇到的值为0，则视为结束信号，取消该队列，并退出SERVER。SERVER每接收到一个数据后显示“(server)receive”。 （3）CLIENT端建立一个key 为75的共享区，当共享取得第一个字节为-1时，Server端空闲，可发送请求。CLIENT随即填入9到0。期间等待server 端的再次空闲。进行完这些操作后，CLIENT退出。CLIENT每发出一次数据后显示“（client）sent”。 （4）父进程在SERVER和CLIENT均退出后结束。 三、实验运行结果 1.涉及的系统调用 （1）shmget( ) 创建、获得一个共享存储区。 系统调用格式：shmid=shmget(key,size,flag) （2）、shmat( ) 共享存储区的附接。从逻辑上将一个共享存储区附接到进程的虚拟地址 空间上。 系统调用格式：virtaddr=shmat(shmid,addr,flag) （3）3、shmdt( ) 把一个共享存储区从指定进程的虚地址空间断开。 系统调用格式：shmdt(addr) （4）、shmctl( ) 共享存储区的控制，对其状态信息进行读取和修改。 系统调用格式：shmctl(shmid,cmd,buf) 2.实验源代码：
进程控制与进程间通信操作系统实验报告
工程大学实验报告 专业班级：姓名：学号： 课程名称：操作系统 实验成绩：指导教师：蔡敦波 实验名称：进程控制与进程间通信 一、实验目的： 1、掌握进程的概念，明确进程和程序的区别。 2、认识和了解并发执行的实质。 3、了解什么是信号。 4、熟悉LINUX系统中进程之间软中断通信的基本原理。 二、实验内容： 1、进程的创建（必做题） 编写一段程序，使用系统调用fork( )创建两个子进程，在系统中有一个父进程和两个子进程活动。让每个进程在屏幕上显示一个字符；父进程显示字符“a”，子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果，并分析原因。 <参考程序>
运行的结果是bca. 首先创建进程p1,向子进程返回0,输出b.又创建进程p2,向子进程返回0，输出c,同时向父进程返回子进程的pid，输出a 2、修改已编写的程序，将每个进程的输出由单个字符改为一句话，再观察程序执行时屏幕上出现的现象，并分析其原因。（必做题） <参考程序> # include
运行的结果是如上图所示. 首先创建进程p1,向子进程返回0,并for语句循环输出child +i字符串.又创建进程p2,向子进程返回0，输出字符串son+i,同时向父进程返回子进程的pid，输出字符串duaghter +i ,各打印5次。
实验6 进程间通信
实验6 进程间通信 一、实验目的： 通过本实验了解和掌握进程间通讯的相关知识， （1）了解进程通信的基本原理。 （2）了解和熟悉管道通信，消息传送机制及共享存储机制。二．实验内容 1.进程的管道通信 阅读下列程序，完成实验任务。 #include
实验报告三进程管理及进程通信
实验三进程管理及进程通信 实验环境： Linux操作系统 实验目的： （1）利用Linux提供的系统调用设计程序，加深对进程概念的理解。 （2）体会系统进程调度的方法和效果。 （3）了解进程之间的通信方式以及各种通信方式的使用。 实验方法： 用vi 编写c 程序（假定程序文件名为prog1.c）编 译程序 $ gcc -o prog1.o prog1.c 或 $ cc -o prog1.o prog1.c 运行 $./prog1.o 实验内容及步骤： 实验1 编写程序。显示进程的有关标识（进程标识、组标识、用户标识等）。经过5 秒钟后，执行另一个程序，最后按用户指示（如：Y/N）结束操作。 编程截图：
运行结果： 实验2 参考例程1，编写程序。实现父进程创建一个子进程。体会子进程与父进程分 别获得不同返回值，进而执行不同的程序段的方法。 例程1：利用fork()创建子进程 /* 用fork()系统调用创建子进程的例子*/ main() { int i; if (fork()) /*父进程执行的程序段*/ i=wait(); /* 等待子进程结束*/{ printf("It is parent process.\n"); printf("The child process,ID number %d, is finished.\n",i); } else{
Printf(“It is child process.\n”); Sleep(10); Exit(); } } 运行结果： 思考： 子进程是如何产生的？又是如何结束的？子进程被创建后它的运行环境是怎样建立的？ 答：是由父进程用fock()函数创建形成的，通过exit()函数自我结束，子进程被创建后核心 将其分配一个进程表项和进程标识符，检查同时运行的进程数目，并且拷贝进程表项的数据，由子进程继承父进程所有文件。 实验3 参考例程2，编写程序。父进程通过循环语句创建若干子进程。探讨进程的家族树 以及子进程继承父进程的资源的关系。 例程2：循环调用fork()创建多个子进程。 /*建立进程树*/ #include
Linux下的进程间通信-详解
Linux下的进程间通信-详解 详细的讲述进程间通信在这里绝对是不可能的事情，而且笔者很难有信心说自己对这一部分内容的认识达到了什么样的地步，所以在这一节的开头首先向大家推荐著 名作者Richard Stevens的著名作品：《Advanced Programming in the UNIX Environment》，它的中文译本《UNIX环境高级编程》已有机械工业出版社出版，原文精彩，译文同样地道，如果你的确对在Linux下编程有浓 厚的兴趣，那么赶紧将这本书摆到你的书桌上或计算机旁边来。说这么多实在是难抑心中的景仰之情，言归正传，在这一节里，我们将介绍进程间通信最最初步和最 最简单的一些知识和概念。 首先，进程间通信至少可以通过传送打开文件来实现，不同的进程通过一个或多个文件来传递信息，事实上，在很多应用系统里，都使用了这种方法。但一般说来， 进程间通信（IPC：InterProcess Communication）不包括这种似乎比较低级的通信方法。Unix系统中实现进程间通信的方法很多，而且不幸的是，极少方法能在所有的Unix系 统中进行移植（唯一一种是半双工的管道，这也是最原始的一种通信方式）。而Linux作为一种新兴的操作系统，几乎支持所有的Unix下常用的进程间通信 方法：管道、消息队列、共享内存、信号量、套接口等等。下面我们将逐一介绍。 2.3.1 管道 管道是进程间通信中最古老的方式，它包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者用于运行于同一台机器上的任意两个进程间的通信。 无名管道由pipe（）函数创建： #include
实验五 进程间通信(二)
湖北工业大学工程技术学院实验报告 课程名称：操作系统实验内容：实验五进程间通信（二） 学院：工程技术学院专业班级：11gb软件2班 教师：贺红艳成绩： 一、实验目的 1、掌握linux系统中进程通信的基本原理。 2、学会使用linux系统中关于进程通信的一些系统调用。 3、掌握信号与共享存储区的使用方法。 二、相关知识背景： (一)信号 1、信号的基本概念 每个信号都对应一个正整数常量(称为signal number,即信号编号。定义在系统头文件
04--Linux系统编程-进程间通信
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，就像读到文件末尾一样。