Linux间的进程通信；以及子进程的创建

  1 "-----第六天-----------------------------------------------------------------------------"
  2 
  3 1.版本控制：svn/git;
  4 
  5 2.进程的概念：
  6     1）程序和进程；
  7         每个进程操作系统会为它分配 0-4G 的虚拟内存空间（32位操作系统）； 其中0-3G为用户内存空间，进程可以对它进行读写操作； 3G - 4G 为系统内核空间，进程没有读写权限。
  8         进程只能读写用户空间，没有权限读写内核空间（kernel）;
  9     2）内存页面的概念
 10         操作系统是按页来管理内存的；每个页有4096个字节。
 11         还可以设置页面属性：如char *str = "hello",字符串在只读数据段，此时只能读，不能写。
 12 
 13     3)进程的4种形态：0-3级； 0 级(内核态)，最高； 3级(用户态);最低。
 14 
 15     2）并发：
 16     3）单道程序设计/多道程序设计
 17     4）CPU/MMU
 18     5）PCB：结构体；其中有一个指针指向文件描述符表；文件描述符表中存储1024个指针；已经打开的文件结构体。
 19         每个进程有属于自己的PCB（进程的状态描述符）；但是多个进程只有一个内核区。
 20 3.环境变量控制
 21     1)echo $名称；    查看该名称的环境变量。
 22     2)查看系统的环境变量： env;
 23     3)获取环境变量的值：char *getenv(const char* name);    获取键name环境变量的值。
 24     4)设置环境变量：int    setenv(const char *name, const char *value, int rewrite);    将环境变量name的值设置为 value。
 25                     如果环境变量 name 已存在；则 rewrite 非0，覆盖原来的环境变量；rewrite为0，则不覆盖原来的环境变量。
 26     5）删除环境变量： void unsetenv(const char *name) 删除 name    的定义;
 27 
 28     6)进程里可以设置自己的环境变量，避免设置在终端，影响他人。
 29 4.环境控制原语：
 30     1）fork:
 31     2)wait/waitpid
 32     3)
 33 
 34 5. printenv.c
 35 
 36 6.进程的状态：4 种或 5 种，都对。 就绪， 运行， 睡眠， 停止。
 37 
 38 7.CPU的组成状态： 运算器，寄存器，控制器，译码器。
 39 
 40     操作系统完成进程调度。（cpu进行时钟周期运算）
 41     cpu的分时复用功能，使进程看起来像多进程。
 42     在单核 cpu 上，同一时间只能有一个进程处于运行状态。那么多核 cpu，就可以有多个进程处于运行状态。
 43 
 44 8.进程原语：
 45     1）创建子进程。pid_t fork();    调用1次，返回两次；在父进程返回子进程的 PID, 在子进程返回0.
 46     2) fork()的工作进程：先调用 creat(),创建一个进程， 在调用 clone()，给子进程复制父进程的内容;
 47     3）pid = fork();    //此时父子进程就都出来了。
 48     4）pid_t getpid();  返回调用进程的PID号；
 49        pid_t getppid();    返回调用进程的父进程的PID号
 50        当在子进程中 getpid(),得到的值与 fork()父进程的返回值相等，都是这个子进程的id号
 51     5）父子进程：读时共享，写时复制。
 52     6）最大创建进程 个数;
 53 9.    uid_t getuid(void);        //返回实际用户id；
 54     uid_t geteuid(void);     //返回有效用户id；
 55     "注意： 文件实际用户与有效用户在创建该文件的家目录下时，如果没有修改，此时是相通的。
 56             当文件被拷贝到root目录时，   "    
 57     设置用户id； chmod 04755;  4 是设置用户ID。  完后效果为 -rwsr-xr-x;  s表示设置了用户ID。
 58             作用：当执行此文件时，执行者有效用户ID变为此文件的所有者。
 59             设置用户组ID： chmod 06777; 6 是设置用户ID和组ID； 效果为： -rwsrwsrwx;
 60 
 61 10. exec族函数的使用：
 62     1）功能： 去磁盘中加载另一个可执行程序，用它的代码段、数据段替换掉当前可执行程序的代码段、数据段；然后从后加载的这个程序退出，被替换的程序后续代码就不执行了。（换核不换壳，）
 63     2）一般情况下：与 fork() 函数联合使用;。  同时exec族函数不会创建新进程， 所以该程序的　ID　不会改变。
 64 
 65     3）函数的返回值： 成功没有返回值，运行完毕，自己退出。
 66                       失败返回 -1;
 67     4）exec族函数的规律： l(list)：命令行参数列表。  p(path): 搜索file时使用path变量。
 68                           v(vector):使用命令行参数数组。  e(environment):使用环境变量的数组，不使用进程原有的环境变量，设置新加载程序的环境变量;
 69     
 70     5）int execl(const char *path, const char *argc, ...); 
 71     例如：execl("./bin/ls", "ls", "-l", "-a", NULL);    这几个参数的作用：其中第一个参数："./bin/ls",命令的环境变量（即所在文件），不可以改变，必须完整正确；
 72         "ls"：占位参数，可以随便写，一般写成该命令。（不能缺失，如果缺失了，就会把后面的命令参数变为占位参数，输出结果会出错。） "-l","-a"该命令的参数。   NULL：卫兵，执行到这里时命令结束。
 73 
 74 11. toupper():将小写字母变为大写。
 75 
 76 12.僵尸进程，孤儿进程：
 77     1）S：睡眠状态；  Z：僵尸状态；
 78     2）僵尸进程的产生原因：用户空间释放，内核空间的PCB没有释放，等着父进程回收。（它消耗的是内核当中的内存资源）
 79             即：子进程退出，父进程没有回收子进程资源（PCB），则子进程变为僵尸进程。
 80     3）子进程的PCB（在内核空间）没有释放,是留给父进程回收用的。只有父进程回收后，僵尸进程才会消失。
 81     4）杀死僵尸进程的办法是杀掉它的父进程。
 82 
 83   孤儿进程：父进程先于子进程结束，则子进程变为孤儿进程，子进程的变为1号进程init进程，由1号进程领养。
 84 
 85   "僵尸进程比孤儿进程更危险， 因为它不会自动关；，而孤儿进程会由 1 号进程领养，当它执行完毕后，会被 1 号进程回收"。
 86   做开发时主要避免的是僵尸进程的产生。用 wait(); waitpid(); 来避免僵尸进程的产生。
 87 
 88 
 89 13. pid_t wait(int* status);  （阻塞函数，等待回收子进程资源；如果没有子进程，返回-1）；
 90     1）返回值：回收的子进程的ID号，    wait(NULL);不关心子进程如何死亡，直接回收。
 91                                     wait(&st); 用st来保存子进程死亡时的状态。
 92     
 93     2）    父进程的ID与它的进程组ID相同；子进程的组ID与父进程的ID相同。
 94         kill -9 -父进程的ID(即组进程的ID)，这个进程组的所有进程都被杀死。"（注意 - 不能少）"
 95 
 96 14.pid_t waitpid(pid_t pid, int *status, int options);    (设置非阻塞。)
 97     第一个参数 pid的值类型：    1） < -1; 回收指定进程组内的任意子进程。（因为父进程与子进程属于统一进程组，父进程与孙子进程属于不同的进程组，但是他们有血缘关系。）
 98                                     -1；回收任意子进程（只要有血缘关系就行。）
 99                                     0； 回收 当前调用 waitpid 一个进程组的所有子进程。
100                                     > 0; 回收指定ID的子进程。
101     第二个参数：保存子进程的推出状态。
102 
103     第三个参数：WNOHANG：如果没有子进程退出，立即返回。（实现了非阻塞的 wait）.
104 
105 15. 阻塞函数：非阻塞函数：在文件open(O_NONBLOCK)的时设置宏；读常规文件不会出现阻塞，当读伪文件时会出现。
106         例如：阻塞读终端； 管道； 网络；
107 
108     设置非阻塞后：应设置轮询。
109         
110 
111 "=========进程间的通信（IPC）==========================================================================================================="
112 一。IPC方法：Linux环境下，多个进程间的通信，需要通过内核，在内核中开辟一块缓冲区（赋予他用户权限）；进程1把数据从用户空间拷贝到内核缓冲区，
113     进程2 把数据从内核缓冲区拷读走，内核提供的这种机制称为进程间的通信(IPC)。
114 
115     进程间的通信；四种方法：1.pipe管道 2.fifo有名管道,3.内存共享映射 4.Unix Domain Socket；
116     管道（使用最简单）；信号（开销最小）；共享映射区（速度最快，效率最高）； 本地套接字（最稳定）；
117 
118 二。pipe管道：
119 1.管道的特性：数据只能一个读，一个写，必须是一个方向。
120             半双工：数据同一时刻只能有一个流向。即只能父进程写，子进程读； 或子进程写， 父进程读。
121             全双工：数据同一时刻可以两个方向。
122             单工：数据只能同一个方向流动。
123             dup2(int oldfd, int newfd);        将第一个参数拷贝给第二个参数。
124             1.其本质是一个伪文件（实为内核缓冲区）
125             2.有两个文件描述符引用，一个读端，一个写端。
126             3.规定数据从管道的写端流入，从读端流出。
127   
128   管道的原理：管道实为内核使用环形队列机制，借助内核缓冲区（4K）实现的。
129 
130   管道的局限性：1.数据不能自己写，自己读；
131                   2.管道中的数据不能反复读取，一旦读走，管道中不再存在。
132                   3.采用半双工通信方式，数据只能在单方向上流动。
133                   4.只能在有血缘关系之间的进程使用管道。
134                   5.只能进行单向通信，双向通信需要建立两个管道。
135 
136 2. pipe()创建管道，用于有血缘关系之间的通信。（采用环形队列实现的）
137     管道使用半双工通信； 创建完管道完后，确定通信方向：父写子读，或子写父读。
138     如果想创建多条管道，一定要先pipe()，再fork(),使子进程得以继承管道。
139 
140     使用管道时的四种注意情况：
141     1） 写段关闭，读端读完管道里的内容时；再次读，返回0，相当于读到文件末尾EOF；
142     2）写端未关闭，写端无数据， 读端读完管道里的数据时，再次读，阻塞。
143     3）读端关闭， 写段写管道，产生SIGPIPE信号，写进程默认情况下会终止进程。
144     4）读端未读管道数据，当写段写满管道后，在此写，阻塞。
145     5）使用管道，无须open，但需手动close。
146 
147     管道的缓冲区大小：1.函数的方法：fpathconf(int fd, int name);  第一个参数为管道描述符；第二个参数为情况标识符。
148                         2.命令： ulimit -a;
149 
150 3.    总结：
151     1.读管道：
152         1.管道中有数据，read返回实际读到的字节数；
153         2.管道中无数据，写端都被关闭，read返回 0，相当于读到文件末尾；
154                         写端未关闭，read函数阻塞等待，（期待不久的将来会有数据到来，但此时会让出CPU资源）
155     2.写管道：
156         1.管道读端全部关闭；进程异常中止（返回一个终止信号）；
157         2.管道读端未关闭：
158             1）管道已写满，write阻塞等待
159 
160             2）管道未写满，write将数据写入，返回实际写入的字节数;
161 
162 
163 "==========================================================================="
164 4.设置非阻塞管道的两种办法：
165     1）fcntl函数设置非阻塞管道；
166         int flg = fcntl(fd, F_GETFD);
167         flg |= O_NONBLOCK;
168         fcntl(fd, F_SETFL, flg);
169     2）打开文件时直接设置非阻塞；
170         int fd = open("/dev/tty", O_RDWR | O_NONBLOCK);
171 当读取一个非阻塞文件，但是此时没有内容，会出错，错误码为EAGAIN;
172 5. read() 函数的返回值四种情况；由于非阻塞设置的存在.
173     1.返回值 > 0; 读到的字节数
174     2.返回值 < 0; 读到文件末尾
175     3.返回值 == -1；但是errno != EAGAIN  或 EWOULDBLOCK
176         if( ret == -1) {
177         if(errno ==  EAGAIN)
178         {
179             说明文件被设置为非阻塞方式读取，此时数据没有到达。
180         }
181         else 
182         {
183             失败；
184         }
185     }
186     4.返回值 == -1， 但是errno == EAGAIN  或 EWOULDBLOCK；
187         说明此时文件被设置为非阻塞方式读取，数据还没有到达。
188 "========================================================================"
189 三. fifo有名管道：解决无血缘关系的进程通信;
190     1.介绍：
191         FIFO文件在磁盘上没有数据块，仅仅用来标识内核中的一条管道。各进程可以打开这个文件进行read/write，实际上是在写内核通道，这样就实现了进程间的通信。
192     1.创建fifo的方法：
193         1)在终端创建一个有名管道；（不常用）用命令；"mkfifo 管道名";
194         2）在代码运行时创建一个有名管道；（常用）用函数；int mkfifo(const char*pathname, mode_t mode);成功返回 0，失败-1；
195 
196     2.利用fifo实现非血缘关系进程间通信
197         1.进程使用 “同一个fifo” 完成进程间通信。
198         2.一个进程以只读方式打开read端，一个程序以只写打开写段。
199         3.一根管道可以打开多个读端，多个写段。（一个写段多个读端； 或 一个读端多个写段）；
200     
201     3.多种特殊情况：
202         当一个写端多个读端时： 每个读端读取到的数据都不相同，因为从管道中读数据，读走之后，管道中的这个数据就不存在了；此时每个读端读到的所有内容合在一起为
203                                 管道写端写入的数据
204         当多个写端一个读端时， 每个写端写入的数据都会被这个读端读取出来；此时管道读到的数据为所有写端写入的数据。
205                             
206 四。mmap 内存映射：
207 
208         从磁盘映射到kernel区，同时kernel区这段内存（映射占用的）开放了用户区的权限；所以进程可以进行访问
209 
210 1.文件是应用于进程间通信
211     1）父子进程之间
212         可以用文件进行通信；
213     2）非血缘关系进程间通信
214         可以用文件进行通信；
215     
216 2.建立映射区，完成进程间通信             
217     1）mmap函数；六个参数的不同意义
218 
219     2）注意事项
220         1.open的时候可以创建一个新文件，但是用此文件创建映射区时，大小不能为0；(可以进行文件拓展后再用来创建映射)
221             mmap使用的时候经常出现总线错误，通常是由于共享文件存储空间大小引起的。
222             
223         2.创建映射区的时候， 隐含着一次对文件的读操作；所以文件打开的方式只能为"读写；或读"。
224           当 MAP_SHARED（对内存的修改将反应到磁盘空间）    时，要求 映射区的权限 <= 文件打开的权限。
225           当 MAP_PRIVATE(对内存修改不会反应到磁盘空间)  时，此时则没有要求。（mmap中的权限是对内存的限制）;
226 
227         3.映射区创建完后关闭文件按描述符，对映射区没有影响。
228         4."最后一个参数，偏移量必须是4K的整数倍。"
229         5.munmap函数传入的地址一定要是mmap的返回地址。坚决杜绝对mmap函数的返回值进行++操作
230         6.mmap创建映射区出错的概率非常高，必须进行出错判断。
231 
232     3）父子进程间的mmap（用户空间独立，内核去各进程共享。）
233         1.先mmap创建映射区
234         2.再fork()共享映射区内存首地址
235         3.指定MAP_SHARED;（必须是 SHARED）；
236 
237     4）非血缘关系进程间通信
238         1.使用“同一个文件”创建映射区
239         2.两个进程，一个以read映射区，一个以write方式打开映射区；
240         3.指定 MAP_SHARED;
241         4）MAP_ANONYMOUS(匿名映射); 不可以用来通信
242         5)/dev/zero(系统的伪文件); 不可以用来通信
243     5）匿名映射
244         linux 创建匿名映射：第四个参数添加 MAP_ANON或MAP__ANONYMOUS;(注意这个匿名宏，只有Linux操作系统可以使用)。
245 
246         UNIX(没有上述的匿名宏)。使用系统中的特殊文件（/dev/zero;(无限读，可以用来创建匿名映射)）
247 
248 3.数据可以重复读取；（即多个读端读取一个写端，读取的内容相同，与fifo不同，取决于读取的数据）。
249 
250 
251 
252 "====================进程间的通信（IPC）================================================================================================"