第8章、进程间通信
嵌入式学院—华清远见旗下品牌：https://www.360docs.net/doc/f19407912.html,
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信
第8章进程间通信
本章目标
在上一章中，读者已经学会了如何创建进程以及如何对进程进行基本的控制，而这些都只是停留在父子进程之间的控制，本章将要学习不同的进程间进行通信的方法，通过本章的学习，读者将会掌握如下内容。
掌握Linux中管道的基本概念
掌握Linux中管道的读写
掌握Linux中消息队列的处理
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信8.1 Linux下进程间通信概述
在上一章中，读者已经知道了进程是一个程序的一次执行。这里所说的进程一般是指运行在用户态的进程，而由于处于用户态的不同进程之间是彼此隔离的，就像处于不同城市的人们，它们必须通过某种方式来进行通信，例如人们现在广泛使用的手机等方式。本章就是讲述如何建立这些不同的通话方式，就像人们有多种通信方式一样。
Linux下的进程通信手段基本上是从UNIX平台上的进程通信手段继承而来的。而对UNIX发展做出重大贡献的两大主力A T&T的贝尔实验室及BSD（加州大学伯克利分校的伯克利软件发布中心）在进程间的通信方面的侧重点有所不同。前者是对UNIX早期的进程间通信手段进行了系统的改进和扩充，形成了“system V IPC”，其通信进程主要局限在单个计算机内；后者则跳过了该限制，形成了基于套接口（socket）的进程间通信机制。而Linux则把两者的优势都继承了下来，如图8.1所示。
n UNIX
。
n System V信号量以及System V
n Posix 信号量以及Posix 共享内存区
现在在Linux中使用较多的进程间通信方式主要有以下几种。
（1）管道（Pipe）及有名管道（named pipe）：管道可用于具有亲缘关系进程间的通信，有名管道，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。
（2）信号（Signal）：信号是在软件层次上对中断机制的一种模拟，它是比较复杂的通信方式，用于通知进程有某事件发生，一个进程收到一个信号与处理器收到一个中断请求效果上可以说是一样的。
（3）消息队列（Messge Queue）：消息队列是消息的链接表，包括Posix消息队列SystemV消息队列。它克服了前两种通信方式中信息量有限的缺点，具有写权限的进程可以按照一定的规则向消息队列中添加新消息；对消息队列有读权限的进程则可以从消息队列中读取消息。
（4）共享内存（Shared memory）：可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据的更新。这种通信方式需要依靠某种同步机制，如互斥锁和信号量等。
《嵌入式Linux 应用程序开发标准教程》——第8章、进程间通信
（5）信号量（Semaphore ）：主要作为进程之间以及同一进程的不同线程之间的同步和互斥手段。
（6）套接字（Socket ）：这是一种更为一般的进程间通信机制，它可用于网络中不同机器之间的进程间通信，应用非常广泛。
本章会详细介绍前5种进程通信方式，对第6种通信方式将会在第10章中单独介绍。
8.2 管道
8.2.1 管道概述
本书在第2章中介绍“ps ”的命令时提到过管道，当时指出了管道是Linux 中一种很重要的通信方式，它是把一个程序的输出直接连接到另一个程序的输入，这里仍以第2章中的“ps –ef | grep ntp ”为例，描
述管道的通信过程，如图8.2所示。
管道是Linux 无名管道，它具有如下特点。
n 它只能用于或者兄弟进程
之间）。
n 它是一个
n 管道也可以以使用普通的read()
和write()等何文件系统，并且只存在于内核的内存空间中。
8.2.2 管道系统调用
1．管道创建与关闭说明
管道是基于文件描述符的通信方式，当一个管道建立时，它会创建两个文件描述符fds[0]和fds[1]，其中fds[0]固定用于读管道，而fd[1]固定用于写管道，如图8.3
所示，这样就构成了一个半双工的通道。
图8.3 Linux 中管道与文件描述符的关系
管道关闭时只需将这两个文件描述符关闭即可，可使用普通的close()函数逐个关闭各个文件描述符。
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信
想一想为什么无名管道只能在具有亲缘关系的进程之间建立？
4．管道使用实例
在本例中，首先创建管道，之后父进程使用fork()函数创建子进程，之后通过关闭父进程的读描述符和子进程的写描述符，建立起它们之间的管道通信。
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信/* pipe.c */
#include
#include
#include
#include
#include
#define MAX_DATA_LEN 256
#define DELAY_TIME 1
int main()
{
pid_t pid;
int pipe_fd[2];
char buf[MAX_DATA_LEN];
const char data[] = "Pipe Test Program";
int real_read, real_write;
memset((void*)buf, 0, sizeof(buf));
/* 创建管道 */
if (pipe(pipe_fd) < 0)
{
printf("pipe create error\n");
exit(1);
}
/* 创建一子进程 */
if ((pid = fork()) == 0)
{
/* 子进程关闭写描述符，并通过使子进程暂停1s等待父进程已关闭相应的读描述符*/ close(pipe_fd[1]);
sleep(DELAY_TIME * 3);
/* 子进程读取管道内容*/
if ((real_read = read(pipe_fd[0], buf, MAX_DATA_LEN)) > 0)
{
printf("%d bytes read from the pipe is '%s'\n", real_read, buf);
}
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信/* 关闭子进程读描述符*/
close(pipe_fd[0]);
exit(0);
}
else if (pid > 0)
{
/* 父进程关闭读描述符，并通过使父进程暂停1s等待子进程已关闭相应的写描述符*/ close(pipe_fd[0]);
sleep(DELAY_TIME);
if((real_write =write(pipe_fd[1], data, strlen(data))) != -1) {
printf("Parent wrote %d bytes : '%s'\n", real_write, data);
}
/*关闭父进程写描述符*/
close(pipe_fd[1]);
/*收集子进程退出信息*/
waitpid(pid, NULL, 0);
exit(0);
}
}
将该程序交叉编译，下载到开发板上的运行结果如下所示：
$ ./pipe
Parent wrote 17 bytes : 'Pipe Test Program'
17 bytes read from the pipe is 'Pipe Test Program'
5．管道读写注意点
n只有在管道的读端存在时，向管道写入数据才有意义。否则，向管道写入数据的进程将收到内核传来的SIGPIPE信号（通常为Broken pipe错误）。
n向管道写入数据时，Linux将不保证写入的原子性，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。如果读进程不读取管道缓冲区中的数据，那么写操作将会一直阻塞。
n父子进程在运行时，它们的先后次序并不能保证，因此，在这里为了保证父子进程已经关闭了相应的文件描述符，可在两个进程中调用sleep()函数，当然这种调用不是很好的解决方法，在后面学到进程之间的同步与互斥机制之后，请读者自行修改本小节的实例程序。
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信
8.2.4 标准流管道
1．标准流管道函数说明
与Linux的文件操作中有基于文件流的标准I/O操作一样，管道的操作也支持基于文件流的模式。这种基于文件流的管道主要是用来创建一个连接到另一个进程的管道，这里的“另一个进程”也就是一个可以进行一定操作的可执行文件，例如，用户执行“ls -l”或者自己编写的程序“./pipe”等。由于这一类操作很常用，因此标准流管道就将一系列的创建过程合并到一个函数popen()中完成。它所完成的工作有以下几步。
n创建一个管道。
n fork()一个子进程。
n在父子进程中关闭不需要的文件描述符。
n执行exec函数族调用。
n执行函数中所指定的命令。
这个函数的使用可以大大减少代码的编写量，但同时也有一些不利之处，例如，它不如前面管道创建的函数那样灵活多样，并且用popen()创建的管道必须使用标准I/O函数进行操作，但不能使用前面的read()、write()一类不带缓冲的I/O函数。
与之相对应，关闭用popen()创建的流管道必须使用函数pclose()来关闭该管道流。该函数关闭标准I/O流，并等待命令执行结束。
2．函数格式
popen()和pclose()函数格式如表8.2和表8.3所示。
表8.2 popen()函数语法要点
所需头文件#include
函数原型FILE *popen(const char *command, const char *type)
command：指向的是一个以null结束符结尾的字符串，这个字符串包含一个shell
命令，并被送到/bin/sh以-c参数执行，即由shell来执行
函数传入值
type：“r”：文件指针连接到command的标准输出，即该命令的结果产生输出
“w”：文件指针连接到command的标准输入，即该命令的结果产生输入
成功：文件流指针
函数返回值
出错：?1
表8.3 pclose()函数语法要点所需头文件#include
函数原型int pclose(FILE *stream)
函数传入值stream：要关闭的文件流
成功：返回由popen()所执行的进程的退出码函数返回值
出错：?1
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信3．函数使用实例
在该实例中，使用popen()来执行“ps -ef”命令。可以看出，popen()函数的使用能够使程序变得短小精悍。
/* standard_pipe.c */
#include
#include
#include
#include
#define BUFSIZE 1024
int main()
{
FILE *fp;
char *cmd = "ps -ef";
char buf[BUFSIZE];
/*调用popen()函数执行相应的命令*/
if ((fp = popen(cmd, "r")) == NULL)
{
printf("Popen error\n");
exit(1);
}
while ((fgets(buf, BUFSIZE, fp)) != NULL)
{
printf("%s",buf);
}
pclose(fp);
exit(0);
}
下面是该程序在目标板上的执行结果。
$ ./standard_pipe
PID TTY Uid Size State Command
1 root 183
2 S init
2 root 0 S [keventd]
3 root 0 S [ksoftirqd_CPU0]
……
74 root 1284 S ./standard_pipe
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信
75 root 1836 S sh -c ps -ef
76 root 2020 R ps –ef
8.2.5 FIFO
1．有名管道说明
前面介绍的管道是无名管道，它只能用于具有亲缘关系的进程之间，这就大大地限制了管道的使用。有名管道的出现突破了这种限制，它可以使互不相关的两个进程实现彼此通信。该管道可以通过路径名来指出，并且在文件系统中是可见的。在建立了管道之后，两个进程就可以把它当作普通文件一样进行读写操作，使用非常方便。不过值得注意的是，FIFO是严格地遵循先进先出规则的，对管道及FIFO的读总是从开始处返回数据，对它们的写则把数据添加到末尾，它们不支持如lseek()等文件定位操作。
有名管道的创建可以使用函数mkfifo()，该函数类似文件中的open()操作，可以指定管道的路径和打开的模式。
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信
O_RDONLY：读管道
O_WRONLY：写管道
函数传入值mode：
O_RDWR：读写管道
O_NONBLOCK：非阻塞
O_CREAT：如果该文件不存在，那么就创建一个新的文件，并用第
三个参数为其设置权限
函数传入值mode：
O_EXCL：如果使用O_CREAT时文件存在，那么可返回错误消息。
这一参数可测试文件是否存在
成功：0
函数返回值
出错：?1
表8.5再对FIFO相关的出错信息做一归纳，以方便用户查错。
表8.5 FIFO相关的出错信息
EACCESS 参数filename所指定的目录路径无可执行的权限
EEXIST 参数filename所指定的文件已存在
ENAMETOOLONG 参数filename的路径名称太长
ENOENT 参数filename包含的目录不存在
ENOSPC 文件系统的剩余空间不足
ENOTDIR 参数filename路径中的目录存在但却非真正的目录
EROFS 参数filename指定的文件存在于只读文件系统内
3．使用实例
下面的实例包含了两个程序，一个用于读管道，另一个用于写管道。其中在读管道的程序里创建管道，并且作为main()函数里的参数由用户输入要写入的内容。读管道的程序会读出用户写入到管道的内容，这两个程序采用的是阻塞式读写管道模式。
以下是写管道的程序：
/* fifo_write.c */
#include
#include
#include
#include
#include
#include
#include
#define MYFIFO "/tmp/myfifo" /* 有名管道文件名*/
#define MAX_BUFFER_SIZE PIPE_BUF /*定义在于limits.h中*/ int main(int argc, char * argv[]) /*参数为即将写入的字符串*/
{
int fd;
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信char buff[MAX_BUFFER_SIZE];
int nwrite;
if(argc <= 1)
{
printf("Usage: ./fifo_write string\n");
exit(1);
}
sscanf(argv[1], "%s", buff);
/* 以只写阻塞方式打开FIFO管道*/
fd = open(MYFIFO, O_WRONLY);
if (fd == -1)
{
printf("Open fifo file error\n");
exit(1);
}
/*向管道中写入字符串*/
if ((nwrite = write(fd, buff, MAX_BUFFER_SIZE)) > 0)
{
printf("Write '%s' to FIFO\n", buff);
}
close(fd);
exit(0);
}
以下是读管道程序：
/*fifo_read.c*/
（头文件和宏定义同fifo_write.c）
int main()
{
char buff[MAX_BUFFER_SIZE];
int fd;
int nread;
/* 判断有名管道是否已存在，若尚未创建，则以相应的权限创建*/
if (access(MYFIFO, F_OK) == -1)
{
if ((mkfifo(MYFIFO, 0666) < 0) && (errno != EEXIST))
{
printf("Cannot create fifo file\n");
exit(1);
}
}
/* 以只读阻塞方式打开有名管道*/
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信if (fd == -1)
{
printf("Open fifo file error\n");
exit(1);
}
while (1)
{
memset(buff, 0, sizeof(buff));
if ((nread = read(fd, buff, MAX_BUFFER_SIZE)) > 0)
{
printf("Read '%s' from FIFO\n", buff);
}
}
close(fd);
exit(0);
}
为了能够较好地观察运行结果，需要把这两个程序分别在两个终端里运行，在这里首先启动读管道程序。读管道进程在建立管道之后就开始循环地从管道里读出内容，如果没有数据可读，则一直阻塞到写管道进程向管道写入数据。在启动了写管道程序后，读进程能够从管道里读出用户的输入内容，程序运行结果如下所示。
终端一:
$ ./fifo_read
Read 'FIFO' from FIFO
Read 'Test' from FIFO
Read 'Program' from FIFO
……
终端二：
$ ./fifo_write FIFO
Write 'FIFO' to FIFO
$ ./fifo_write Test
Write 'Test' to FIFO
$ ./fifo_write Program
Write 'Program' to FIFO
……
《嵌入式Linux 应用程序开发标准教程》——第8章、进程间通信
8.3 信号
8.3.1 信号概述
信号是UNIX 中所使用的进程通信的一种最古老的方法。它是在软件层次上对中断机制的一种模拟，是一种异步通信方式。信号可以直接进行用户空间进程和内核进程之间的交互，内核进程也可以利用它来通知用户空间进程发生了哪些系统事件。它可以在任何时候发给某一进程，而无需知道该进程的状态。如果该进程当前并未处于执行态，则该信号就由内核保存起来，直到该进程恢复执行再传递给它为止；如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞被取消时才被传递给进程。
在第2章kill 命令中曾讲解到“?l ”选项，这个选项可以列出该系统所支持的所有信号的列表。在笔者的系统中，信号值在32之前的则有不同的名称，而信号值在32以后的都是用“SIGRTMIN ”或“SIGRTMAX ”开头的，这就是两类典型的信号。前
称为非实时信号）；后的信号，称为“可靠呢？这里首先要介绍一个完4个重要事
件来刻画号处理函数，如图阶段。要注意以由用户进程来完成，
图8.6 信号生命周期
一个不可靠信号的处理过程是这样的：如果发现该信号已经在进程中注册，那么就忽略该信号。因此，若前一个信号还未注销又产生了相同的信号就会产生信号丢失。而当可靠信号发送给一个进程时，不管该信号是否已经在进程中注册，都会被再注册一次，因此信号就不会丢失。所有可靠信号都支持排队，而所有不可靠信号都不支持排队。
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信用户进程对信号的响应可以有3种方式。
n忽略信号，即对信号不做任何处理，但是有两个信号不能忽略，即SIGKILL 及SIGSTOP。
n捕捉信号，定义信号处理函数，当信号发生时，执行相应的自定义处理函数。
n执行缺省操作，Linux对每种信号都规定了默认操作。
Linux中的大多数信号是提供给内核的，表8.6列出了Linux中最为常见信号的含义及其默认操作。
表8.6 常见信号的含义及其默认操作
信号名含义默认操
作
SIGHUP 该信号在用户终端连接（正常或非正常）结束时发出，通常是在终
端的控制进程结束时，通知同一会话内的各个作业与控制终端不再
关联
终止
SIGINT 该信号在用户键入INTR字符（通常是Ctrl-C）时发出，终端驱动程序
发送此信号并送到前台进程中的每一个进程
终止
SIGQUIT 该信号和SIGINT类似，但由QUIT字符（通常是Ctrl-\）来控制终止
SIGILL 该信号在一个进程企图执行一条非法指令时（可执行文件本身出现
错误，或者试图执行数据段、堆栈溢出时）发出
终止
SIGFPE 该信号在发生致命的算术运算错误时发出。这里不仅包括浮点运算
错误，还包括溢出及除数为0等其他所有的算术错误
终止
SIGKILL 该信号用来立即结束程序的运行，并且不能被阻塞、处理或忽略终止SIGALRM 该信号当一个定时器到时的时候发出终止SIGSTOP 该信号用于暂停一个进程，且不能被阻塞、处理或忽略暂停进程
SIGTSTP 该信号用于交互停止进程，用户键入SUSP字符时（通常是Ctrl+Z）
发出这个信号
停止进程
SIGCHLD 子进程改变状态时，父进程会收到这个信号忽略SIGABORT 进程异常终止时发出
8.3.2 信号发送与捕捉
发送信号的函数主要有kill()、raise()、alarm()以及pause()，下面就依次对其进行介绍。
1．kill()和raise()
（1）函数说明。
kill()函数同读者熟知的kill系统命令一样，可以发送信号给进程或进程组（实际上，kill系统命令只是kill()函数的一个用户接口）。这里需要注意的是，它不仅可以中止进程（实际上发出SIGKILL信号），也可以向进程发送其他信号。
与kill()函数所不同的是，raise()函数允许进程向自身发送信号。
（2）函数格式。
表8.7列出了kill()函数的语法要点。
表8.7 kill()函数语法要点
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信
所需头文件#include
#include
函数原型int kill(pid_t pid, int sig)
正数：要发送信号的进程号
0：信号被发送到所有和当前进程在同一个进程组的进程
?1：信号发给所有的进程表中的进程（除了进程号最大的进程外
pid：
<-1：信号发送给进程组号为-pid的每一个进程
函数传入值
sig：信号
成功：0
函数返回值
出错：?1
表8.8列出了raise()函数的语法要点。
表8.8 raise()函数语法要点
所需头文件#include
#include
函数原型int raise(int sig)
函数传入值sig：信号
成功：0
函数返回值
出错：?1
（3）函数实例。
下面这个示例首先使用fork()创建了一个子进程，接着为了保证子进程不在父进程调用kill()之前退出，在子进程中使用raise()函数向自身发送SIGSTOP信号，使子进程暂停。接下来再在父进程中调用kill()向子进程发送信号，在该示例中使用的是SIGKILL，读者可以使用其他信号进行练习。
/* kill_raise.c */
#include
#include
#include
#include
#include
int main()
{
pid_t pid;
int ret;
/* 创建一子进程 */
if ((pid = fork()) < 0)
{
printf("Fork error\n");
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信}
if (pid == 0)
{
/* 在子进程中使用raise()函数发出SIGSTOP信号,使子进程暂停*/
printf("Child(pid : %d) is waiting for any signal\n", getpid());
raise(SIGSTOP);
exit(0);
}
else
{
/* 在父进程中收集子进程发出的信号，并调用kill()函数进行相应的操作*/
if ((waitpid(pid, NULL, WNOHANG)) == 0)
{
if ((ret = kill(pid, SIGKILL)) == 0)
{
printf("Parent kill %d\n",pid);
}
}
waitpid(pid, NULL, 0);
exit(0);
}
}
该程序运行结果如下所示：
$ ./kill_raise
Child(pid : 4877) is waiting for any signal
Parent kill 4877
2．alarm()和pause()
（1）函数说明。
alarm()也称为闹钟函数，它可以在进程中设置一个定时器，当定时器指定的时间到时，它就向进程发送SIGALARM信号。要注意的是，一个进程只能有一个闹钟时间，如果在调用alarm()之前已设置过闹钟时间，则任何以前的闹钟时间都被新值所代替。
pause()函数是用于将调用进程挂起直至捕捉到信号为止。这个函数很常用，通常可以用于判断信号是否已到。
（2）函数格式。
表8.9列出了alarm()函数的语法要点。
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信表8.9 alarm()函数语法要点
所需头文件#include
函数原型unsigned int alarm(unsigned int seconds)
函数传入值seconds：指定秒数，系统经过seconds秒之后向该进程发送SIGALRM信号
成功：如果调用此alarm()前，进程中已经设置了闹钟时间，则返回上一个闹钟时间的剩余时间，否则返回0
函数返回值
出错：?1
表8.10列出了pause()函数的语法要点。
表8.10 pause()函数语法要点
所需头文件#include
函数原型int pause(void)
函数返回值?1，并且把error值设为EINTR
（3）函数实例。
该实例实际上已完成了一个简单的sleep()函数的功能，由于SIGALARM默认的系统动作为终止该进程，因此程序在打印信息之前，就会被结束了。代码如下所示：
/* alarm_pause.c */
#include
#include
#include
int main()
{
/*调用alarm定时器函数*/
int ret = alarm(5);
pause();
printf("I have been waken up.\n",ret); /* 此语句不会被执行*/ }
$./alarm_pause
Alarm clock
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信
《嵌入式Linux应用程序开发标准教程》——第8章、进程间通信act：指向结构sigaction的一个实例的指针，指定对特定信号的处理
oldact：保存原来对相应信号的处理
成功：0
函数返回值
出错：?1
这里要说明的是sigaction()函数中第2个和第3个参数用到的sigaction结构。这是一个看似非常复杂的结构，希望读者能够慢慢阅读此段内容。
首先给出了sigaction的定义，如下所示：
struct sigaction
{
void (*sa_handler)(int signo);
sigset_t sa_mask;
int sa_flags;
void (*sa_restore)(void);
}
sa_handler是一个函数指针，指定信号处理函数，这里除可以是用户自定义的处理函数外，还可以为SIG_DFL（采用缺省的处理方式）或SIG_IGN（忽略信号）。它的处理函数只有一个参数，即信号值。
sa_mask是一个信号集，它可以指定在信号处理程序执行过程中哪些信号应当被屏蔽，在调用信号捕获函数之前，该信号集要加入到信号的信号屏蔽字中。
sa_flags中包含了许多标志位，是对信号进行处理的各个选择项。它的常见可选值如表8.13所示。
表8.13 常见信号的含义及其默认操作
选项含义
SA_NODEFER \ SA_NOMASK 当捕捉到此信号时，在执行其信号捕捉函数时，系统不会自动屏蔽此信号
SA_NOCLDSTOP 进程忽略子进程产生的任何SIGSTOP、SIGTSTP、SIGTTIN和SIGTTOU信号
SA_RESTART 令重启的系统调用起作用
SA_ONESHOT \
SA_RESETHAND
自定义信号只执行一次，在执行完毕后恢复信号的系统默认动作
（3）使用实例。
第一个实例表明了如何使用signal()函数捕捉相应信号，并做出给定的处理。这里，my_func就是信号处理的函数指针。读者还可以将其改为SIG_IGN或SIG_DFL查看运行结果。第二个实例是用sigaction()函数实现同样的功能。
以下是使用signal()函数的示例：
/* signal.c */
#include
#include
进程间通信的四种方式
一、剪贴板 1、基础知识 剪贴板实际上是系统维护管理的一块内存区域，当在一个进程中复制数据时，是将这个数据放到该块内存区域中，当在另一个进程中粘贴数据时，是从该内存区域中取出数据。 2、函数说明： (1)、BOOL OpenClipboard( ) CWnd类的OpenClipboard函数用于打开剪贴板。若打开剪贴板成功，则返回非0值。若其他程序或当前窗口已经打开了剪贴板，则该函数返回0值，表示打开失败。若某个程序已经打开了剪贴板，则其他应用程序将不能修改剪贴板，直到前者调用了CloseClipboard函数。 (2)、BOOL EmptyClipboard(void) EmptyClipboard函数将清空剪贴板，并释放剪贴板中数据的句柄，然后将剪贴板的所有权分配给当前打开剪贴板的窗口。 (3)、HANDLE SetClipboardData(UINT uFormat, HANDLE hMem) SetClipboardData函数是以指定的剪贴板格式向剪贴板上放置数据。uFormat指定剪贴板格式，这个格式可以是已注册的格式，或是任一种标准的剪贴板格式。CF_TEXT表示文本格式，表示每行数据以回车换行(0x0a0x0d)终止，空字符作为数据的结尾。hMem指定具有指定格式的数据的句柄。hMem参数可以是NULL，指示采用延迟提交技术，则该程序必须处理WM_RENDERFORMA T和WM_RENDERALLFORMATS消息。应用程序在调用SetClipboardData函数之后，就拥有了hMem参数所标识的数据对象，该应用程序可以读取该数据对象，但在应用程序调用CloseClipboard函数之前，它不能释放该对象的句柄，或者锁定这个句柄。若hMem标识了一个内存对象，那么这个对象必须是利用GMEM_MOVEABLE标志调用GlobalAlloc函数为其分配内存。 注意：调用SetClipboardData函数的程序必须是剪贴板的拥有者，且在这之前已经打开了剪贴板。 延迟提交技术：当一个提供数据的进程创建了剪贴板数据之后，直到其他进程获取剪贴板数据之前，这些数据都要占据内存空间。若在剪贴板上放置的数据过大，就会浪费内存空间，降低对资源的利用率。为了避免这种浪费，就可以采用延迟提交计数，也就是由数据提供进程先提供一个指定格式的空剪贴板数据块，即把SetClipboardData函数的hMem参数设置为NULL。当需要获取数据的进程想要从剪贴板上得到数据时，操作系统会向数据提供进程发送WM_RENDERFORMA T消息，而数据提供进程可以响应这个消息，并在此消息的响应函数中，再一次调用SetClipboardData函数，将实际的数据放到剪贴板上。当再次调用SetClipboardData函数时，就不再需要调用OpenClipboard函数，也不再需要调用EmptyClipboard函数。也就是说，为了提高资源利用率，避免浪费内存空间，可以采用延迟提交技术。第一次调用SetClipboardData函数时，将其hMem参数设置为NULL，在剪贴板上以指定的剪贴板格式放置一个空剪贴板数据块。然后直到有其他进程需要数据或自身进程需要终止运行时再次调用SetClipboardData函数，这时才真正提交数据。 (4)、HGLOBAL GlobalAlloc( UINT uFlags,SIZE_T dwBytes); GlobalAlloc函数从堆上分配指定数目的字节。uFlags是一个标记，用来指定分配内存的方式，uFlags为0，则该标记就是默认的GMEM_FIXED。dwBytes指定分配的字节数。
进程和进程间的通信
1、进程概念； 2、进程的控制： （1）生成一个进程：fork （2）进程的同步：wait waitpid （3）进程的退出：exit _exit （4）进程“脱胎换骨”：exec函数族 3、进程通信 （1）进程为什么需要通信？ （2）linux下进程如何通信 ●早期的unix通信方式 无名管道；有名管道;信号 ●sysem v的通信方式：共享内存、消息队列、信号量 ●BSD的通信方式：socket 4、无名管道：适用于有血缘关系进程通信 小任务1：父进程通过无名管道向子进程发送字符串“Hello,you man!”,子进程接收到后显示出来，然后子进程退出，最后父进程退出。 （1）创建子进程：fork （2）创建管道 #include
char buf[]="Hello,young man!"; ret=pipe(pipefd);//创建管道（1） if(ret<0) { perror("Failed to create pipe:"); return -1; } pid=fork(); //能够把（1）语句放此注释的下一样？？ if(pid<0) { perror("Failed to create child process:"); return -1; } if(pid>0) { close(pipefd[0]);//父进程中关闭无关的读端 write(pipefd[1],buf,strlen(buf)); wait(NULL); printf("Parent process exit!\n"); } else { char receive_buf[100]; int count; close(pipefd[1]);//子进程中关闭无关的写端 count=read(pipefd[0],receive_buf,100); if(count>0) { receive_buf[count]='\0'; printf("Child process receive a string:%s\n",receive_buf); } printf("Child process exit!\n"); } return 0; } 5、有名管道（fifo） (1)文件系统中可见，可以通过mkfifo 命令来创建一个有名管道 eg: mkfifo -m 0666 myfifo (2)有名管道的使用跟普通文件一样：open read write close,不用使用lseek!!!! 任务2： 进程1通过有名管道把键盘输入字符串发送给进程2,进程2收到后显
进程间通信实验报告
进程间通信实验报告 班级：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.这一点有助于理解消息转送的实现机理。
Windows进程间各种通信方式浅谈
Windows进程间各种通信方式浅谈 1、Windows进程间通信的各种方法 进程是装入内存并准备执行的程序，每个进程都有私有的虚拟地址空间，由代码、数据以及它可利用的系统资源(如文件、管道等)组成。 多进程/多线程是Windows操作系统的一个基本特征。Microsoft Win32应用编程接口(Application Programming Interface, API) 提供了大量支持应用程序间数据共享和交换的机制，这些机制行使的活动称为进程间通信(InterProcess Communication, IPC)，进程通信就是指不同进程间进行数据共享和数据交换。 正因为使用Win32 API进行进程通信方式有多种，如何选择恰当的通信方式就成为应用开发中的一个重要问题， 下面本文将对Win32中进程通信的几种方法加以分析和比较。 2、进程通信方法 2.1 文件映射 文件映射(Memory-Mapped Files)能使进程把文件内容当作进程地址区间一块内存那样来对待。因此，进程不必使用文件I/O操作，只需简单的指针操作就可读取和修改文件的内容。 Win32 API允许多个进程访问同一文件映射对象，各个进程在它自己的地址空间里接收内存的指针。通过使用这些指针，不同进程就可以读或修改文件的内容，实现了对文件中数据的共享。 应用程序有三种方法来使多个进程共享一个文件映射对象。 (1)继承：第一个进程建立文件映射对象，它的子进程继承该对象的句柄。 (2)命名文件映射：第一个进程在建立文件映射对象时可以给该对象指定一个名字(可与文件名不同)。第二个进程可通过这个名字打开此文件映射对象。另外，第一个进程也可以通过一些其它IPC机制(有名管道、邮件槽等)把名字传给第二个进程。 (3)句柄复制：第一个进程建立文件映射对象，然后通过其它IPC机制(有名管道、
进程同步与通信作业习题与答案
第三章 一．选择题(50题) 1.以下_B__操作系统中的技术是用来解决进程同步的。 A.管道 B.管程 C.通道 2.以下_B__不是操作系统的进程通信手段。 A.管道 B.原语 C.套接字 D.文件映射 3.如果有3个进程共享同一程序段，而且每次最多允许两个进程进入该程序段，则信号量的初值应设置为_B__。 4.设有4个进程共享一个资源，如果每次只允许一个进程使用该资源，则用P、V操作管理时信号量S的可能取值是_C__。 ,2,1,0，-1 ,1,0，-1，-2 C. 1,0，-1，-2，-3 ,3，2,1,0 5.下面有关进程的描述，是正确的__A__。 A.进程执行的相对速度不能由进程自己来控制 B.进程利用信号量的P、V 操作可以交换大量的信息 C.并发进程在访问共享资源时，不可能出现与时间有关的错误 、V操作不是原语操作 6.信号灯可以用来实现进程之间的_B__。 A.调度 B.同步与互斥 C.同步 D.互斥 7.对于两个并发进程都想进入临界区，设互斥信号量为S，若某时S=0，表示_B__。 A.没有进程进入临界区 B.有1个进程进入了临界区 C. 有2个进程进入了临界区 D. 有1个进程进入了临界区并且另一个进程正等待进入 8. 信箱通信是一种_B__方式 A.直接通信 B.间接通信 C.低级通信 D.信号量 9.以下关于临界区的说法，是正确的_C__。
A.对于临界区，最重要的是判断哪个进程先进入 B.若进程A已进入临界区，而进程B的优先级高于进程A，则进程B可以 打断进程A而自己进入临界区 C. 信号量的初值非负，在其上只能做PV操作 D.两个互斥进程在临界区内，对共享变量的操作是相同的 10. 并发是指_C__。 A.可平行执行的进程 B.可先后执行的进程 C.可同时执行的进程 D.不可中断的进程 11. 临界区是_C__。 A.一个缓冲区 B.一段数据区 C.一段程序 D.栈 12．进程在处理机上执行，它们的关系是_C__。 A.进程之间无关，系统是封闭的 B.进程之间相互依赖相互制约 C.进程之间可能有关，也可能无关 D.以上都不对 13. 在消息缓冲通信中，消息队列是一种__A__资源。 A.临界 B.共享 C.永久 D.可剥夺 14. 以下关于P、V操作的描述正确的是__D_。 A.机器指令 B. 系统调用 C.高级通信原语 D.低级通信原语 15.当对信号量进行V源语操作之后，_C__。 A.当S＜0，进程继续执行 B.当S＞0，要唤醒一个就绪进程 C. 当S＜＝ 0，要唤醒一个阻塞进程 D. 当S＜＝0，要唤醒一个就绪 16.对临界区的正确论述是__D_。 A.临界区是指进程中用于实现进程互斥的那段代码 B. 临界区是指进程中用于实现进程同步的那段代码 C. 临界区是指进程中用于实现进程通信的那段代码 D. 临界区是指进程中访问临界资源的那段代码 17. __A__不是进程之间的通信方式。 A.过程调用 B.消息传递 C.共享存储器 D.信箱通信 18. 同步是指进程之间逻辑上的__A__关系。
进程之间的通信实验
实验：进程之间的通信管道 1．Pipe函数与进程通信 下面实验为使用管道进行父子进程间通信。程序首先判断参数是否合法，因为输入的字符将从父进程通过发送到子进程中。然后，调用pipe函数创建父子进程用于通信的管道。使用fork函数创建子进程时，子进程会获得与父进程相同的资源，其中包括文件描述符信息。因此，调用fork函数须在pipe函数调用前。 当父子进程通过管道进行通信时，files[1]为用于数据写入的文件描述符.因此,在子进程中,要读取管道中的数据可以调用read函数，而读取得文件描述符为files[0]。对于父进程而言，写入数据需要调用write 函数，要写入的文件描述为files[1]。 #include
操作系统精髓与设计原理-第11章_IO管理和磁盘调度,第12章_文件管理
第十一章 I/O管理和磁盘调度 复习题 11.1列出并简单定义执行I/O的三种技术。 ·可编程I/O：处理器代表进程给I/O模块发送给一个I/O命令，该进程进入忙等待，等待操作的完成，然后才可以继续执行。 ·中断驱动I/O：处理器代表进程向I/O模块发送一个I/O命令，然后继续执行后续指令，当I/O模块完成工作后，处理器被该模块中断。如果该进程不需要等待I/O完成，则后续指令可以仍是该进程中的指令，否则，该进程在这个中断上被挂起，处理器执行其他工作。 ·直接存储器访问（DMA）：一个DMA模块控制主存和I/O模块之间的数据交换。为传送一块数据，处理器给DMA模块发送请求，只有当整个数据块传送完成后，处理器才被中断。 11.2逻辑I/O和设备I/O有什么区别？ ·逻辑I/O：逻辑I/O模块把设备当作一个逻辑资源来处理，它并不关心实际控制设备的细节。逻辑I/O模块代表用户进程管理的一般I/O功能，允许它们根据设备标识符以及诸如打开、关闭、读、写之类的简单命令与设备打交道。 ·设备I/O：请求的操作和数据（缓冲的数据、记录等）被转换成适当的I/O指令序列、通道命令和控制器命令。可以使用缓冲技术，以提高使用率。 11.3面向块的设备和面向流的设备有什么区别？请举例说明。 面向块的设备将信息保存在块中，块的大小通常是固定的，传输过程中一次传送一块。通常可以通过块号访问数据。磁盘和磁带都是面向块的设备。 面向流的设备以字节流的方式输入输出数据，其末使用块结构。终端、打印机通信端口、鼠标和其他指示设备以及大多数非辅存的其他设备，都属于面向流的设备。 11.4为什么希望用双缓冲区而不是单缓冲区来提高I/O的性能？ 双缓冲允许两个操作并行处理，而不是依次处理。典型的，在一个进程往一个缓冲区中传送数据（从这个缓冲区中取数据）的同时，操作系统正在清空（或者填充）另一个缓冲区。 11.5在磁盘读或写时有哪些延迟因素？ 寻道时间，旋转延迟，传送时间 11.6简单定义图11.7中描述的磁盘调度策略。 FIFO:按照先来先服务的顺序处理队列中的项目。 SSTF:选择使磁头臂从当前位置开始移动最少的磁盘I/O请求。 SCAN:磁头臂仅仅沿一个方向移动，并在途中满足所有未完成的请求，直到
Linux下的进程间通信-详解
Linux下的进程间通信-详解 详细的讲述进程间通信在这里绝对是不可能的事情，而且笔者很难有信心说自己对这一部分内容的认识达到了什么样的地步，所以在这一节的开头首先向大家推荐著 名作者Richard Stevens的著名作品：《Advanced Programming in the UNIX Environment》，它的中文译本《UNIX环境高级编程》已有机械工业出版社出版，原文精彩，译文同样地道，如果你的确对在Linux下编程有浓 厚的兴趣，那么赶紧将这本书摆到你的书桌上或计算机旁边来。说这么多实在是难抑心中的景仰之情，言归正传，在这一节里，我们将介绍进程间通信最最初步和最 最简单的一些知识和概念。 首先，进程间通信至少可以通过传送打开文件来实现，不同的进程通过一个或多个文件来传递信息，事实上，在很多应用系统里，都使用了这种方法。但一般说来， 进程间通信（IPC：InterProcess Communication）不包括这种似乎比较低级的通信方法。Unix系统中实现进程间通信的方法很多，而且不幸的是，极少方法能在所有的Unix系 统中进行移植（唯一一种是半双工的管道，这也是最原始的一种通信方式）。而Linux作为一种新兴的操作系统，几乎支持所有的Unix下常用的进程间通信 方法：管道、消息队列、共享内存、信号量、套接口等等。下面我们将逐一介绍。 2.3.1 管道 管道是进程间通信中最古老的方式，它包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者用于运行于同一台机器上的任意两个进程间的通信。 无名管道由pipe（）函数创建： #include
进程间的通信
实验三进程间的通信 【实验类型】 综合性实验 【目的要求】 学习如何利用管道机制、消息缓冲队列、共享存储区机制进行进程间的通讯，并加深对上述通信机制的理解。 【内容提要】 1、了解系统调用pipe()、msgget()、msgsnd()、msgrcv ()、msgctl()、shmget()、shmat()、shmdt()、shmctl()的功能和实现过程。 2、编写一段程序，使其用管道来实现父子进程之间的进程通讯。子进程向父进程发送自己的进程标识符，以及字符串“is sending a message to parent!”。父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上，然后终止。 3、编写一段程序，使用系统调用fork()来创建两个子进程CLIENT进程和SERVER进程，使其用消息缓冲队列来实现CLIENT进程和SERVER进程之间的通信。SERVER端建立一个Key为75的消息队列，等待其他进程发来的消息。当遇到类型为1的消息，则作为结束信号，取消该队列，并退出SERVER。SERVER每接收到一条消息后显示一句“(server) received”。CLIENT端使用Key为75的消息队列，先后发送类型从10到1的消息，然后退出。最后的一个消息，即是SERVER端需要的结束信号。CLIENT每发送一条消息后显示一句“(client) sent”。父进程在SERVER和CLIENT均退出后结束。 4、编写一个与3具有类似功能的程序，使其用共享存储区来实现两个进程之间的通讯。 【主要仪器设备】 每人一台计算机，硬件要求:CPU PII以上,64M内存,1OOM硬盘空间即可；软件要求: Linux操作系统。
进程间通信方式比较
进程间的通信方式： 1.管道（pipe）及有名管道（named pipe）： 管道可用于具有亲缘关系进程间的通信，有名管道除了具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。 2.信号（signal）： 信号是在软件层次上对中断机制的一种模拟，它是比较复杂的通信方式，用于通知进程有某事件发生，一个进程收到一个信号与处理器收到一个中断请求效果上可以说是一致得。 3.消息队列（message queue）： 消息队列是消息的链接表，它克服了上两种通信方式中信号量有限的缺点，具有写权限得进程可以按照一定得规则向消息队列中添加新信息；对消息队列有读权限得进程则可以从消息队列中读取信息。 消息缓冲通信技术是由Hansen首先提出的,其基本思想是:根据”生产者-消费者”原理,利用内存中公用消息缓冲区实现进程之间的信息交换. 内存中开辟了若干消息缓冲区,用以存放消息.每当一个进程向另一个进程发送消息时,便申请一个消息缓冲区,并把已准备好的消息送到缓冲区,然后把该消息缓冲区插入到接收进程的消息队列中,最后通知接收进程.接收进程收到发送里程发来的通知后,从本进程的消息队列中摘下一消息缓冲区,取出所需的信息,然后把消息缓冲区不定期给系统.系统负责管理公用消息缓冲区以及消息的传递. 一个进程可以给若干个进程发送消息,反之,一个进程可以接收不同进程发来的消息.显然,进程中关于消息队列的操作是临界区.当发送进程正往接收进程的消息队列中添加一条消息时,接收进程不能同时从该消息队列中到出消息:反之也一样. 消息缓冲区通信机制包含以下列内容:
(1) 消息缓冲区,这是一个由以下几项组成的数据结构: 1、消息长度 2、消息正文 3、发送者 4、消息队列指针 （2）消息队列首指针m-q,一般保存在PCB中。 （1）互斥信号量m-mutex,初值为1，用于互斥访问消息队列，在PCB中设置。 （2）同步信号量m-syn,初值为0，用于消息计数，在PCB中设置。（3）发送消息原语send （4）接收消息原语receive(a) 4.共享内存（shared memory）： 可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据得更新。这种方式需要依靠某种同步操作，如互斥锁和信号量等。 这种通信模式需要解决两个问题：第一个问题是怎样提供共享内存；第二个是公共内存的互斥关系则是程序开发人员的责任。 5.信号量（semaphore）： 主要作为进程之间及同一种进程的不同线程之间得同步和互斥手段。 6.套接字（socket）； 这是一种更为一般得进程间通信机制，它可用于网络中不同机器之间的进程间通信，应用非常广泛。 https://www.360docs.net/doc/f19407912.html,/eroswang/archive/2007/09/04/1772350.aspx linux下的进程间通信-详解
进程控制与进程间通信操作系统实验报告
工程大学实验报告 专业班级：姓名：学号： 课程名称：操作系统 实验成绩：指导教师：蔡敦波 实验名称：进程控制与进程间通信 一、实验目的： 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次。
进程间的通信
# 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。 # 有名管道(named pipe) ：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。 # 信号量( semophore ) ：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。 # 消息队列( message queue ) ：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。 # 信号( sinal ) ：信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。# 共享内存( shared memory ) ：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。 # 套接字( socket ) ：套接口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。 windows进程通信的几种方式（转） 2008-10-13 16:47 1 文件映射 文件映射(Memory-Mapped Files)能使进程把文件内容当作进程地址区间一块内存那样来对待。因此，进程不必使用文件I/O操作，只需简单的指针操作就可读取和修改文件的内容。 Win32 API允许多个进程访问同一文件映射对象，各个进程在它自己的地址空间里接收内存的指针。通过使用这些指针，不同进程就可以读或修改文件的内容，实现了对文件中数据的共享。 应用程序有三种方法来使多个进程共享一个文件映射对象。 (1)继承：第一个进程建立文件映射对象，它的子进程继承该对象的句柄。 (2)命名文件映射：第一个进程在建立文件映射对象时可以给该对象指定一个名字(可与文件名不同)。第二个进程可通过这个名字打开此文件映射对象。另外，第一个进程也可以通过一些其它IPC机制(有名管道、邮件槽等)把名字传给第二个进程。 (3)句柄复制：第一个进程建立文件映射对象，然后通过其它IPC机制(有名管道、邮件槽等)把对象句柄传递给第二个进程。第二个进程复制该句柄就取得对该文件映射对象的访问权限。 文件映射是在多个进程间共享数据的非常有效方法，有较好的安全性。但文件映射只能用于本地机器的进程之间，不能用于网络中，而开发者还必须控制进程间的同步。 2 共享内存 Win32 API中共享内存(Shared Memory)实际就是文件映射的一种特殊情况。进程在创建文件映射对象时用0xFFFFFFFF来代替文件句柄(HANDLE)，就表示了对应的文件映射对象是从操作系统页面文件访问内存，其它进程打开该文件映射
第3章 进程同步与通信 练习题答案
第3章进程同步与通信练习题 (一)单项选择题 1.临界区是指( )。 A.并发进程中用于实现进程互斥的程序段 B．并发进程中用于实现进程同步的程序段 C．并发进程中用户实现进程通信的程序段 D．并发进程中与共享变量有关的程序段 2．相关临界区是指( )。 A.一个独占资源 B．并发进程中与共享变量有关的程序段 c．一个共享资源 D．并发进程中涉及相同变量的那些程序段 3．管理若干进程共享某一资源的相关临界区应满足三个要求,其中( )不考虑。 A一个进程可以抢占己分配给另一进程的资源 B．任何进程不应该无限地逗留在它的临界区中c．一次最多让一个进程在临界区执行 D．不能强迫一个进程无限地等待进入它的临界区4、( )是只能由P和v操作所改变的整型变量。 A共享变量 B．锁 c整型信号量 D．记录型信号量 5．对于整型信号量，在执行一次P操作时，信号量的值应( )。 A．不变 B．加1 C减1 D．减指定数值 6．在执行v操作时，当信号量的值( )时，应释放一个等待该信号量的进程。 A>0 B.<0 c.>=0 D.<=0 7.Pv操作必须在屏蔽中断下执行，这种不可变中断的过程称为( )。 A初始化程序 B．原语 c．子程序 D控制模块 8．进程间的互斥与同步分别表示了各进程间的( )。 A．竞争与协作 B．相互独立与相互制约 c．不同状态 D．动态性与并发性 9并发进程在访问共享资源时的基本关系为( )。 A．相互独立与有交往的 B．互斥与同步 c并行执行与资源共享 D信息传递与信息缓冲 10．在进程通信中，( )常用信件交换信息。 A．低级通信 B．高级通信 c．消息通信 D．管道通信 11．在间接通信时，用send(N，M)原语发送信件，其中N表示( )。 A．发送信件的进程名 B．接收信件的进程名 C信箱名 D．信件内容 12．下列对线程的描述中，( )是错误的。 A不同的线程可执行相同的程序 B．线程是资源分配单位 c．线程是调度和执行单位 D．同一 进程中的线程可共享该进程的主存空间 13．实现进程互斥时，用( )对应，对同一个信号量调用Pv操作实现互斥。 A．一个信号量与一个临界区 B．一个信号量与—个相关临界区 c．一个信号量与一组相关临界 区 D一个信号量与一个消息 14．实现进程同步时，每一个消息与一个信号量对应，进程( )可把不同的消息发送出去。 A．在同一信号量上调用P操作 B在不同信号量上调用P操作 c．在同一信号量上调用v操作D．在不同信号量上调用v操作 (二)填空题 1．目前使用的计算机的基本特点是处理器______执行指令。 2．进程的______是指进程在顺序处理器上的执行是按顺序进行的。 3．当一个进程独占处理器顺序执行时，具有______和______两个特性。 4．进程的封闭性是指进程的执行结果只取决于______，不受外界影响。 5 进程的可再现性是指当进程再次重复执行时，必定获得______的结果。 6．一个进程的工作在没有全部完成之前,另一个进程就可以开始工作，则称这些进程为______.
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) 消息队列和过程调用往往单独使用,也就是说它们通常提供了自己的同步机制.相反,共享内存区
用socket实现进程间通信
实验报告 班级011291 班 学生姓名 学号 实验成绩
一、实验题目： 实现最简单实用的通信程序socket. 二、实验目的： 通过对socket的编写，了解socket通信的原理.了解TCP通信的整个过程.以及Linux下C语言的socket函数. 三、实验设备及环境： 1. 硬件设备：PC机一台 2. 软件环境：安装Linux操作系统，并安装相关的程序开发环境，如C \C++\tsh\bsh等编程语言环境。 四、实验内容及要求： 用C语言编程实现linux简单的聊天室功能。 ?用户程序命名为2.c;服务器程序命名为1.c ?要求client可以通过socket连接server ?Client与server可以相互通信，实现交互 五．代码(针对实验1，2，请将最终源代码粘贴至此；正式报告中将下面例子删除) 服务端: #include
#include
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，就像读到文件末尾一样。