xxxxxxxxxx
4
1
书写一个程序同时监听管道的读端和写端。
2
// 如果可写，则写入4096个字节
3
// 如果可读，则读取1024个字节
4
描述一下运行的现象

xxxxxxxxxx
102
1
#include <57header.h>
2

3
int main(int argc,char*argv[])
4
{
5
int pipe_fd = open("1.pipe", O_RDWR);
6

7
fd_set set_read;
8
fd_set set_write;
9
FD_ZERO(&set_read);
10
FD_ZERO(&set_write);
11

12
while(1){
13
FD_SET(pipe_fd, &set_read);
14
FD_SET(pipe_fd, &set_write);
15
select(10,&set_read, &set_write, NULL, NULL);
16

17
if(FD_ISSET(pipe_fd, &set_write)){
18
  char buf[4096] = {0};
19
  write(pipe_fd, buf, sizeof(buf));
20
  printf("write once \n");
21
}
22
if(FD_ISSET(pipe_fd, &set_read)){
23
  char buf[1024] = {0};
24
  read(pipe_fd, buf, sizeof(buf));
25
  printf("read once \n");
26
}
27

28
sleep(1);
29
}
30

31
close(pipe_fd);
32
return 0;
33
}
34
// 执行的结果: 
35
write once 
36
write once 
37
read once 
38
write once 
39
read once 
40
write once 
41
read once 
42
write once 
43
read once 
44
write once 
45
read once 
46
write once 
47
read once 
48
write once 
49
read once 
50
write once 
51
read once 
52
write once 
53
read once 
54
write once 
55
read once 
56
write once 
57
read once 
58
write once 
59
read once 
60
write once 
61
read once 
62
write once 
63
read once 
64
write once 
65
read once 
66
write once 
67
read once 
68
write once 
69
read once 
70
write once 
71
read once 
72
write once 
73
read once 
74
read once 
75
write once 
76
read once 
77
read once 
78
read once 
79
read once 
80
write once 
81
read once 
82
read once 
83
read once 
84
read once 
85
// 第一次循环:  管道为空,所以可写; 管道没有数据,不可读
86
// 第二次循环<->其后的多次循环: 管道不满, 可以写; 管道有数据, 所以可读
87
上面操作, 写快(每次写4096), 读慢(每次读1024)
88
// 当某次循环: 管道写满, 不再可写; 管道有数据, 可读
89
//            可读
90
//            可读
91
//            可读
92
//  读了一些空间出来, 有变得可写, 可读
93
//  写满, 不可写, 可读
94
//            可读
95
//            可读
96
//            可读
97
//  读了一些空间出来, 有变得可写, 可读
98
//  写满, 不可写, 可读
99
//            可读
100
//            可读
101
//            可读
102
// ....

xxxxxxxxxx
4
1
编写C程序A和B，A和B通过管道进行通信： 程序A先后执行3次printf("Helloworld\n");
2
// 第一次显示在A的标准输出当中；
3
// 第二次显示在B的标准输出当中；
4
// 第三次显示在A的标准输出当中。

xxxxxxxxxx
19
1
// a.c
2
#include <57header.h>
3

4
int main(int argc,char*argv[])
5
{
6
int pipe_fd = open("1.pipe", O_WRONLY);
7

8
printf("Helloworld1 \n");
9

10
int stdout_bak = 10;
11
dup2(STDOUT_FILENO, stdout_bak);
12
dup2(pipe_fd, STDOUT_FILENO);
13
printf("Helloworld2 \n");
14

15
dup2(stdout_bak, STDOUT_FILENO);
16
printf("Helloworld3 \n");
17
close(pipe_fd);
18
return 0;
19
}

xxxxxxxxxx
14
1
// b.c
2
#include <57header.h>
3

4
int main(int argc,char*argv[])
5
{
6
int pipe_fd = open("1.pipe", O_RDONLY);
7

8
char buf[60] = {0};
9
read(pipe_fd, buf, sizeof(buf));
10
printf("%s \n", buf);
11

12
close(pipe_fd);
13
return 0;
14
}

说明一下什么是进程，什么是虚拟内存，什么是虚拟CPU？

xxxxxxxxxx
6
1
//进程是计算机中正在运行程序的实例, 是操作系统分配内存并能独立完成任务的基本单元, 每个进程都拥有自己独立的内存地址空间和系统资源, 操作系统通过创建和管理进程, 来使多个不同的/独立的任务能在一台计算机上正常执行.
2

3
//虚拟内存是操作系统为进程提供的一片逻辑上连续的/完整的地址空间, 这个地址空间是一种逻辑上的存在, 是通过逻辑上的记录维护的, 当一个进程真正使用这些地址空间的时候, 操作系统会把这个虚拟的/逻辑上的地址, 经过映射转化为真实的物理地址, 进而访问真实的物理地址.
4
//对进程来说，虚拟内存提供了一个逻辑上的连续的地址空间，虽然这些地址最终可能映射到物理内存中的时候是非连续的区域, 但是这种机制有利于每一个进程对自己的内存空间进行良好的管理, 并且每个进程的虚拟内存对其他进程是不可见的, 这增强了进程间的解耦性和独立性, 进而保证了一个操作系统中多进程间的稳定运行. 
5

6
// 所谓虚拟CPU是指, 操作系统为每一个进程分配运行时间片, 由于每一个进程的时间片比较小(通常几毫秒到几十毫秒之间), 这让计算机可以保证在极短的时间内, 每个程序都可以获得在CPU上执行代码逻辑的机会, 而从人能感知的时间尺度上, 我们从感受上, 感觉一个进程一直在CPU上执行没有间断(其实间断了, 只不过间断的时间很短, 又获得了时间片开始执行, 人类感知中在一直运行), 主观上认为每一个进程都独享了CPU一直在运行.

什么是僵尸进程? 僵尸进程有什么危害?

​x
1
// 在操作系统中, 如果一个进程的子进程先退出，系统不会自动清理掉子进程的环境，而必须由这个父进程来完成清理工作(读取退出状态, 释放资源等 )，如果父进程不做清理工作，则已经退出的子进程将成为僵尸进程，在系统中如果存在的僵尸进程过多，将会影响系统的性能， 所以必须对僵尸进程进行处理.
2

3
// 当我们的代码创建了一个子进程执行某种任务, 但是在这个子进程退出的时候,我们未调用父进程未做清理工作, 导致僵尸产生. 
4
// 一般在我们书写代码和运行程序的过程中, 我们可能在一个进程中启动另外一个子进程处理一个"独立的"业务逻辑, 这种行为经常是频繁且重复的, 这也就意味着, 一旦我们因为代码疏漏,未对退出的子进程进行清理, 这可能会快速的导致接连不断的僵尸进程产生, 这些僵尸进程会随着数量变多而大量占用系统资源(尤其是内存资源, 以及进程pid的编号), 有可能导致系统资源不足, 进而影响系统的正常工作.