Linux进程编程基础介绍

Linux系统是一个多进程的系统，它的进程之间具有并行性、互不干扰等特点。也就是说，每个进程都是一个独立的运行单位，拥有各自的权利和责任。其中，各个进程都运行在独立的虚拟地址空间，因此，即使一个进程发生异常，它也不会影响到系统中的其他进程。

Linux进程是一个具有独立功能的程序关于某个数据集合的一次可以并发执行的运行活动，是处于活动状态的计算机程序。进程作为构成系统的基本细胞，不仅是系统内部独立运行的实体，而且是独立竞争资源的基本实体。

Linux进程是一个程序的一次执行的过程，同时也是资源分配的最小单元。它和程序是有本质区别的，程序是静态的，它是一些保存在磁盘上的指令的有序集合，没有任何执行的概念；进程是一个动态的概念，它是程序执行的过程，包括了动态创建、调度和消亡的整个过程。它是程序执行和资源管理的最小单位。

进程是程序的执行过程，根据它的生命周期可以划分成3种状态：(1)、执行态：该进程正在运行，即进程正在占用CPU；(2)、就绪态：进程已经具备执行的一切条件，正在等待分配CPU的处理时间片；(3)、等待态(阻塞态)：进程不能使用CPU，若等待事件发生（等待的资源分配到）则可将其唤醒。

导致进程终止的三种情况：正常终止、异常终止、外部干扰。

终止进程的主要操作过程如下；(1)、找到指定进程的PCB；(2)、终止该进程的运行；(3)、回收该进程所占用的全部资源；(4)、终止其所有子孙进程，回收它们所占用的全部资源；(5)、将被终止进程的PCB从原来队列中摘走。

进程阻塞的过程如下：(1)、立即停止当前进程的执行；(2)、现行进程的CPU现场保存；(3)、现行状态由“运行”改为“阻塞”；(4)、转到进程调度程序。

Linux 系统的进程状态模型的各种状态：用户状态、内核状态、内存中就绪、内存中睡眠、就绪且换出、睡眠且换出、被抢先、创建状态、僵死状态。

进程的上下文是由用户级上下文、寄存器上下文以及系统级上下文组成。主要内容是该进程用户空间内容、寄存器内容以及与该进程有关的内核数据结构。当系统收到一个中断、执行系统调用或内核做上下文切换时，就会保存进程的上下文。一个进程是在它的上下文中运行的，若要调度进程，就要进行上下文切换。

在Linux系统中，用户创建一个进程的唯一方法就是使用系统调用fork。

Linux系统调用exit，是进程用来终止执行时调用的。进程发出该调用，内核就会释放该进程所占的资源，释放进程上下文所占的内存空间，保留进程表项，将进程表项中纪录进程状态的字段设为僵死状态。内核在进程收到不可捕捉的信号时，会从内核内部调用exit，使得进程退出。父进程通过wait得到其子进程的进程表项中记录的计时数据，并释放进程表项。最后，内核使得进程1（init 进程，init进程是系统所有进程的起点，它的进程号是1。）接收终止执行的进程的所有子进程。如果有子进程僵死，就向init 进程发出一个SIGCHLD 的软中断信号。

一个进程通过调用wait来与它的子进程同步，如果发出调用的进程没有子进程则返回一个错误，如果找到一个僵死的子进程就取子进程的PID及退出时提供给父进程的参数。如果有子进程，但没有僵死的子进程，发出调用的进程就睡眠在一个可中断的级别上，直到收到一个子进程僵死（SIGCLD）的信号或其他信号。

进程控制的一个主要内容就是对其他程序引用。该功能是通过系统调用exec来实现的，该调用将一个可执行的程序文件读入，代替发出调用的进程执行。内核读入程序文件的正文，清除原先进程的数据区，清除原先用户软中断信号处理函数的地址，当exec调用返回时，进程执行新的正文。

Linux系统是一个分时系统，内核给每个进程分一个时间片，该进程的时间片用完就会调度另一个进程执行。

进程调度分成两个部分，一个是调度的时机，即什么时候调度；一个是调度的算法，即如何调度和调度哪个进程。

fork函数启动一个新的进程，这个进程几乎是当前进程的一个拷贝：子进程和父进程使用相同的代码段；子进程复制父进程的堆栈段和数据段。这样，父进程的所有数据都可以留给子进程，但是，子进程一旦开始运行，虽然它继承了父进程的一切数据，但实际上数据却已经分开，相互之间不再有影响了，也就是说，它们之间不再共享任何数据了。它们再要交互信息时，只有通过进程间通信来实现。

对于父进程，fork函数返回了子程序的进程号，而对于子程序，fork函数则返回零。在操作系统中，我们用ps函数就可以看到不同的进程号，对父进程而言，它的进程号是由比它更低层的系统调用赋予的，而对于子进程而言，它的进程号即是fork函数对父进程的返回值。

实际执行fork时，物理空间上两个进程的数据段和堆栈段都还是共享着的，当有一个进程写了某个数据时，这时两个进程之间的数据才有了区别，系统就将有区别的"页"从物理上也分开。系统在空间上的开销就可以达到最小。

系统调用exec是用来执行一个可执行文件来代替当前进程的执行映像。需要注意的是，该调用并没有生成新的进程，而是在原有进程的基础上，替换原有进程的正文，调用前后是同一个进程，进程号PID不变。但执行的程序变了（执行的指令序列改变了）。

系统调用exec和fork经常结合使用，父进程fork一个子进程，在子进程中调用exec来替换子进程的执行映像，并发的执行一些操作。

系统调用exit的功能是终止发出调用的进程。

系统调用wait的功能是发出调用的进程只要有子进程，就睡眠直到它们中的一个终止为止。

函数调用sleep可以用来使进程挂起指定的秒数。

获得进程相关的ID：与进程相关的ID有，(1)、真正用户标识号（UID）：该标识号负责标识运行进程的用户；(2)、有效用户标识号（EUID）：该标识号负责标识以什么用户身份来给新创建的进程赋所有权、检查文件的存取权限和检查通过系统调用kill向进程发送软中断信号的许可权限；(3)、真正用户组标识号(GID)：负责标识运行进程的用户所属的组ID；(4)、有效用户组标识号(EGID)：用来标识目前进程所属的用户组。可能因为执行文件设置set-gid位而与gid不同；(5)、进程标识号(PID)：用来标识进程；(6)、进程组标识号(process group ID)：一个进程可以属于某个进程组。可以发送信号给一组进程。注意，它不同与gid。

如果要获得进程的用户标识号，用getuid调用。调用geteuid是用来获得进程的有效用户标识号。

如果要获得运行进程的用户组ID，使用getgid调用来获得真正的用户组ID，用getegid获得有效的用户组ID。

如果要获得进程的ID，使用getpid调用；要获得进程的父进程的ID，使用getppid调用。

如果要获得进程所属组的ID，使用getpgrp调用；若要获得指定PID进程所属组的ID用getpgid调用。

调用setuid为当前发出调用的进程设置真正和有效用户ID。参数uid是新的用户标识号（该标识号应该在/etc/passwd文件中存在）。调用setgid设置当前发出调用的进程的真正、有效用户组ID。该调用允许进程指定进程的用户组ID为参数gid，如果进程的有效用户ID不是超级用户，该参数gid必须等于真正用户组ID、有效用户组ID中的一个。

调用setpgrp用来将发出调用的进程的进程组ID设置成与该进程的PID相等。注意，以后由这个进程派生的子进程都拥有该进程组ID（除非修改子进程的进程组ID）。调用setpgid用来将进程号为参数pid的进程的进程组ID设定为参数pgid。如果参数pid为0，则修改发出调用进程的进程组ID。

chdir是用来将进程的当前工作目录改为由参数指定的目录。

系统调用chroot用来改变发出调用进程的根（“/”）目录。

系统调用nice用来改变进程的优先权。

所谓僵尸进程，是指使用fork后，子进程先于父进程结束，但是因为父子进程间依然有关系，那么子进程实际上不会真正意义上终结，如果查看当前进程表，会发现该进程依然存在。僵尸进程是非常特殊的一种，它已经放弃了几乎所有内存空间，没有任何可执行代码，也不能被调度，仅仅在进程列表中保留一个位置，记载该进程的退出状态等信息供其他进程收集，除此之外，僵尸进程不再占有任何内存空间。

系统对一个用户可以同时运行的进程数是有限制的，对超级用户没有该限制，但也不能超过进程表的最大表项的数目。

Linux下一个进程在内存里有三部的数据，就是"代码段"、"堆栈段"和"数据段"。这三个部分也是构成一个完整的执行序列的必要的部分。"代码段"，顾名思义，就是存放了程序代码的数据，假如机器中有数个进程运行相同的一个程序，那么它们就可以使用相同的代码段。"堆栈段"存放的就是子程序的返回地址、子程序的参数以及程序的局部变量。而数据段则存放程序的全局变量，常数以及动态数据分配的数据空间（比如用malloc 之类的函数取得的空间）。系统如果同时运行数个相同的程序，它们之间就不能使用同一个堆栈段和数据段。

test_fork1.cpp：

 

1. //fork函数的使用  
2. //输出结果的顺序和进程调度的顺序有关  
3. #include <stdio.h>  
4. #include <stdlib.h>  
5. #include <sys/types.h>  
6. #include <sys/stat.h>  
7. #include <sys/uio.h>  
8. #include <unistd.h>  
9. #include <fcntl.h>  
10. #include <errno.h>  
11. #include <string.h>  
12. #include <sys/wait.h>  
13.   
14. extern int errno;  
15.   
16. int main()  
17. {  
18.     char buf[100];  
19.     pid_t cld_pid;  
20.     int fd;  
21.     int status;  
22.   
23.     if ((fd = open("temp", O_CREAT|O_TRUNC|O_RDWR,S_IRWXU)) == -1) {  
24.         printf("open error %d\n",errno);  
25.         exit(1);  
26.     }  
27.   
28.     strcpy(buf, "This is parent process write\n");  
29.   
30.     if ((cld_pid = fork()) == 0) { /* 这里是子进程执行的代码 */  
31.         strcpy(buf, "This is child process write\n");  
32.         printf("This is child process\n");  
33.         printf("My PID(child) is %d\n", getpid()); /*打印出本进程的ID*/  
34.         printf("My parent PID is %d\n", getppid()); /*打印出父进程的ID*/  
35.         write(fd, buf, strlen(buf));  
36.         close(fd);  
37.         exit(0);  
38.     } else { /* 这里是父进程执行的代码 */  
39.         printf("This is parent process\n");  
40.         printf("My PID(parent) is %d\n",getpid());/*打印出本进程的ID*/  
41.         printf("My child PID is %d\n", cld_pid);/*打印出子进程的ID*/  
42.         write(fd, buf, strlen(buf));  
43.         close(fd);  
44.     }  
45.       
46.     //父子进程是彼此相互独立运行的，所以要想让父进程等待子进程，只需使用wait()系统调用。  
47.     wait(&status); /* 如果此处没有这一句会如何？*/  
48.       
49.     return 0;  
50. }  

test_fork2.cpp：

 

 

1. //fork的使用  
2. //屏幕上交替出现子进程与父进程各打印出的一千条信息  
3. #include <stdio.h>  
4. #include <stdlib.h>  
5. #include <sys/types.h>  
6. #include <sys/stat.h>  
7. #include <sys/uio.h>  
8. #include <unistd.h>  
9. #include <fcntl.h>  
10. #include <errno.h>  
11. #include <string.h>  
12. #include <sys/wait.h>  
13.   
14. int main()  
15. {  
16.     int i;  
17.     if (fork() == 0)    {  
18.         /* 子进程程序 */  
19.         for (i = 1; i <1000; i ++)  
20.             printf("This is child process\n");  
21.     } else {  
22.         /* 父进程程序*/  
23.         for (i = 1; i <1000; i ++)  
24.         printf("This is parent process\n");  
25.     }  
26.       
27.     return 0;  
28. }  

test_fork3.cpp：

 

 

1. //waitpid的使用  
2. #include <stdio.h>  
3. #include <stdlib.h>  
4. #include <sys/types.h>  
5. #include <sys/wait.h>  
6. #include <unistd.h>  
7.   
8. int main()  
9. {  
10.     pid_t pc, pr;  
11.     pc=fork();  
12.     if (pc<0) /* 如果fork 出错 */  
13.         printf("Error occured on forking.\n");  
14.     else if (pc == 0) {/* 如果是子进程 */  
15.         sleep(10);/* 睡眠10 秒 */  
16.         //exit(0);  
17.         return 0;  
18.     }  
19.       
20.     /* 如果是父进程 */  
21.     do {  
22.         pr = waitpid(pc, NULL, WNOHANG); /* 使用了WNOHANG 参数，waitpid 不会在这里等待 */  
23.           
24.         if (pr == 0) {/* 如果没有收集到子进程 */  
25.             printf("No child exited\n");  
26.             sleep(1);  
27.         }  
28.     } while (pr == 0); /* 没有收集到子进程，就回去继续尝试 */  
29.       
30.     if (pr == pc)  
31.         printf("successfully get child %d\n", pr);  
32.     else  
33.         printf("some error occured\n");  
34.       
35.     return 0;  
36. }  

test_fork4.cpp：

 

 

1. //fork的使用  
2. //此代码来自：http://www.linuxidc.com/Linux/2013-06/85903p6.htm  
3. #include<stdio.h>  
4. #include<stdlib.h>  
5. #include<sys/types.h>  
6. #include<unistd.h>  
7. #include<sys/wait.h>  
8.   
9. int main()  
10. {  
11.     pid_t child1, child2, child;  
12.     /*先创建子进程1*/  
13.     child1 = fork();  
14.     /*子进程1的出错处理*/  
15.     if (child1 == -1) {  
16.         printf("Child1 fork error\n");  
17.         exit(1);  /*异常退出*/  
18.     } else if(child1 == 0) { /*在子进程1中调用execlp()函数*/  
19.         printf("I am child1 and I execute 'ls -l'\n");  
20.         if (execlp("ls", "ls", "-l", NULL) < 0) {  
21.             printf("Child1 execlp error\n");  
22.         }  
23.     } else {/*在父进程中再创建进程2,然后等待两个子进程的退出*/  
24.         child2 = fork();  
25.         /*子进程2的出错处理*/  
26.         if (child2 == -1) {  
27.             printf("Child2 fork error\n");  
28.             exit(1);  
29.         } else if (child2 == 0) {/*在子进程2中使其暂停5s*/  
30.             printf("I am child2. I will sleep for 5 seconds!\n");  
31.             sleep(5);  
32.             printf("I am child2. I have awaked and I will exit!\n");  
33.             exit(0);  
34.         }  
35.   
36.         printf("I am father progress\n");  
37.         child = waitpid(child1, NULL, 0);/*阻塞式等待*/  
38.           
39.         if (child == child1)   
40.             printf("I am father progress. I get child1 exit code:%d\n", child);  
41.         else  
42.             printf("Error occured!\n");  
43.   
44.         do {  
45.             child = waitpid(child2, NULL, WNOHANG);/*非阻塞式等待*/  
46.             if (child == 0) {  
47.                 printf("I am father progress. The child2 progress has not exited!\n");  
48.                 sleep(1);  
49.             }  
50.         } while (child == 0);  
51.   
52.         if (child == child2)  
53.             printf("I am father progress. I get child2 exit code:%d\n",child);  
54.         else  
55.             printf("Erroe occured!\n");  
56.     }  
57.       
58.     exit(0);  
59. }  

 

管道和信号是进程间通信的两种机制。操作系统中的每一个管道有两个文件描述符，一个文件描述符用来读，另一个用来写。信号是一个软件中断，主要用于进程间异步事件通知与进程控制。

进程间的通信类型有6种：(1)、管道(pipe)和有名管道(FIFO)；(2)、信号(signal)；(3)、共享内存；(4)、消息队列；(5)、信号量；(6)、套接字(socket)。

进程间通信目的有5种：(1)、数据传输：一个进程需要将它的数据发送给另一个进程；(2)、共享数据：多个进程想要共享数据，一个进程对共享数据进行修改后，别的进程可以立刻看到；(3)、通知事件：一个进程需要向另一个或一组进程发送消息，通知它(它们)发生了某种事件(如进程终止时要通知父进程)；(4)、资源共享：多个进程之间共享同样的资源，为了做到这一点，需要内核提供锁和同步机制；(5)、进程控制：有些进程希望完全控制另一个进程的执行(如Debug进程)，此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

管道是Linux中最常用的进程间通信的IPC机制。使用管道时，一个进程的输出可成为另外一个进程的输入。当输入/输出的数据量特别大时，管道这种IPC机制非常有用。

在Linux中，通过将两个file结构指向同一个临时的VFS索引节点，而两个VFS索引节点又指向同一个物理页而实现管道。

管道允许在进程之间按先进先出的方式传送数据，管道也能使进程同步执行。管道传统的实现方法是通过文件系统作为存储数据的地方。有两种类型的管道：一种是无名管道，简称为管道；另一种是有名管道，也称为FIFO。进程使用系统调用open来打开有名管道，使用系统调用pipe来建立无名管道。使用无名管道通讯的进程，必须是发出pipe调用的进程及其子进程。使用有名管道通讯的进程没有上述限制。

系统调用dup是用来复制一个文件描述符，也就是将进程u区的文件描述符表中的一项复制一份，使得这两项同时指向系统文件表的同一表项。

pipe管道：若要创建一个简单的管道，可以使用系统调用pipe()，它接收一个参数，也就是一个包括两个整数的数组。如果系统调用成功，此数组将包括管道使用的两个文件描述符，一个为读端，一个为写端。pipe管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；只能用于父子进程或者兄弟进程之间。管道主要用于父子进程间通信。实际上，通常先创建一个管道，再通过fork函数创建一个子进程，其实pipe的两个文件描述符指向相同的内存空间，只不过filedes[1]有写权限，filedes[0]有读权限。

由于进程的文件描述符0指向标准输入(键盘),1指向标准输出(屏幕)，2指向标准错误(屏幕)，所以进程可用的文件描述符从3开始。进程是通过对文件描述符的操作从而实现对文件描述符所指向文件的操作。

标准流管道：管道的操作也支持文件流模式，这种管道称为标准流管道。标准流管道通过popen()创建一个管道popen()会调用fork()产生一个子进程，执行一个shell以运行命令来开启一个进程，并把执行结果写入管道中，然后返回一个文件指针。程序通过文件指针可读取管道中的内容。使用popen()创建的标准流管道，需要用pclose()进行关闭。

命名管道(FIFO)：和一般的管道基本相同，但也有一些显著的不同，(1)、命名管道是在文件系统中作为一个特殊的设备文件而存在的；(2)、不同祖先的进程之间可以通过命名管道共享数据；(3)、当共享命名管道的进程执行完所有的I/O操作以后，命名管道将继续保存在文件系统中，以便以后使用；(4)、普通管道只能由父子兄弟等相关进程使用，它们共同的祖先进程创建了管道。但是，通过命名管道，不相关的进程也能交换数据；(5)、一旦已经用mkfifo函数创建了一个FIFO，就可用open打开它。实际上，一般的文件I/O函数(close、read、write、unlink等)都可用于FIFO。

test_pipe1.cpp：

 

1. //pipe管道的使用  
2. #include <unistd.h>  
3. #include <sys/types.h>  
4. #include <sys/stat.h>   
5. #include <errno.h>  
6. #include <stdio.h>  
7. #include <stdlib.h>  
8.   
9. void look_into_pipe()   
10. {  
11.     int n;  
12.     int fd[2];  
13.     char line[1024];  
14.     struct stat buf;  
15.       
16.     if (pipe(fd) < 0) { /*创建管道*/  
17.         printf("pipe error.\n");  
18.         return;  
19.     }  
20.       
21.     fstat(fd[0], &buf);  
22.     if (S_ISFIFO(buf.st_mode)) { /*S_ISFIFO为测试此文件类型是否为管道文件*/  
23.         printf("fd[0]: FIFO file type.\n");  
24.     }  
25.     printf("fd[0]: inode=%d\n", buf.st_ino);  
26.       
27.     fstat(fd[1], &buf);  
28.     if (S_ISFIFO(buf.st_mode)) {  
29.         printf("fd[1]: FIFO file type.\n");  
30.     }  
31.     printf("fd[1]: inode=%d\n", buf.st_ino);  
32.       
33.     write(fd[1], "hello world.\n", 12);  
34.     n = read(fd[0], line, 512 );  
35.     write(STDOUT_FILENO, line, n);  
36.       
37.     n = write(fd[0], "HELLO WORLD.\n", 12); /*0端只允许读，1端才允许写，这样做是为了测试*/  
38.     if (-1 == n)  
39.         printf("\nwrite error\n") ;  
40. }  
41.   
42. int main()  
43. {  
44.     look_into_pipe() ;  
45. }  

test_pipe2.cpp：

 

 

1. //pipe管道的使用  
2. #include <unistd.h>  
3. #include <sys/types.h>  
4. #include <sys/wait.h>  
5. #include <errno.h>  
6. #include <stdio.h>  
7. #include <string.h>  
8. #include <stdlib.h>  
9.   
10. int main(){  
11.     int pipe_fd[2];  
12.     pid_t pid;  
13.     char buf_r[100];  
14.     char *p_wbuf;  
15.     int r_num;  
16.     memset(buf_r, 0, sizeof(buf_r));  
17.       
18.     if (pipe(pipe_fd) < 0){ //创建管道  
19.         perror("pipe create error\n");  
20.         return -1;  
21.     }  
22.       
23.     if ((pid = fork()) == 0){//表示在子进程中  
24.         //关闭管道写描述符，进行管道读操作  
25.         printf("child pipe1=%d; pipe2=%d\n", pipe_fd[0], pipe_fd[1]) ;  
26.         close(pipe_fd[1]);  
27.         //管道描述符中读取  
28.         sleep(2);  
29.           
30.         if ((r_num = read(pipe_fd[0], buf_r, 100)) > 0) {  
31.             printf("%d numbers read from the pipe, data is %s\n", r_num, buf_r);  
32.         }  
33.           
34.         close(pipe_fd[0]);  
35.         exit(0);  
36.     } else if (pid > 0) {//表示在父进程中，父进程写  
37.         //关闭管道读描述符，进行管道写操作  
38.         printf("parent pipe1=%d; pipe2=%d\n", pipe_fd[0], pipe_fd[1]) ;  
39.         close(pipe_fd[0]);  
40.           
41.         if (write(pipe_fd[1], "Hello", 5) != -1)  
42.             printf("parent write1 success!\n");  
43.         if (write(pipe_fd[1], " Pipe", 5) != 1)  
44.             printf("parent write2 success!\n");  
45.           
46.         close(pipe_fd[1]);  
47.         sleep(3);  
48.         //waitpid()与wait()功能类似，都是用户主进程等待子进程结束或中断  
49.         waitpid(pid, NULL, 0);  
50.         exit(0);  
51.     } else {  
52.         perror("fork error");  
53.         exit(-1);  
54.     }  
55.       
56.     return 0;  
57. }  

test_pipe3.cpp：

 

 

1. //标准流管道的使用  
2. #include <stdio.h>  
3. #include <unistd.h>  
4. #include <stdlib.h>  
5. #include <fcntl.h>  
6. #define BUFSIZE 1024  
7.   
8. int main()  
9. {  
10.     FILE *fp;  
11.     char *cmd = "ps -ef";  
12.     char buf[BUFSIZE];  
13.     buf[BUFSIZE] = '\0';  
14.       
15.     if ((fp=popen(cmd, "r")) == NULL)  
16.         perror("popen");  
17.       
18.     while ((fgets(buf, BUFSIZE, fp)) != NULL)  
19.         printf("%s", buf);  
20.       
21.     pclose(fp);  
22.     exit(0);  
23. }  

test_pipe4.cpp：

 

 

1. #命名管道FIFO的使用,创建命名管道并写入数据  
2. #include <sys/types.h>  
3. #include <unistd.h>  
4. #include <sys/stat.h>  
5. #include <string.h>  
6. #include <stdio.h>  
7. #include <fcntl.h>  
8. #define FIFO "/tmp/fifo"  
9.   
10. int main()  
11. {  
12.     char buffer[80];  
13.     int fd;  
14.     int n;  
15.     int ret;  
16.     char info[80];  
17.       
18.     unlink(FIFO); /*若存在该管道文件，则进行删除*/  
19.     ret = mkfifo(FIFO, 0600); /*0600表明只有该用户进程有读写权限*/  
20.     if (ret) {  
21.         perror("mkfifo error");  
22.         return -1;  
23.     }  
24.       
25.     memset(info, 0x00, sizeof(info));  
26.     strcpy(info, "happy new year!");  
27.     fd = open(FIFO, O_WRONLY);  
28.     n=write(fd, info, strlen(info));  
29.     if (n < 0) {  
30.         perror("write error") ;  
31.         return -1 ;  
32.     }  
33.       
34.     close(fd);  
35.       
36.     return 0 ;  
37. }  

test_pipe5.cpp：

 

 

1. //命名管道FIFO的使用，从命名管道中读取数据  
2. //此测试用例，与test_pipe4一起使用  
3. #include <sys/types.h>  
4. #include <unistd.h>  
5. #include <sys/stat.h>  
6. #include <string.h>  
7. #include <stdio.h>  
8. #include <fcntl.h>  
9. #define FIFO "/tmp/fifo"  
10.   
11. int main()  
12. {  
13.     char buffer[80];  
14.     int fd;  
15.     int n ;  
16.     char info[80] ;  
17.     fd= open(FIFO, O_RDONLY);  
18.     n = read(fd, buffer, 80);  
19.       
20.     if (n < 0) {  
21.         perror("read error") ;  
22.         return -1 ;  
23.     }  
24.       
25.     printf("buffer=%s\n", buffer);  
26.     close(fd);  
27.     return 0 ;  
28. }  

 

信号是进程间通信机制中唯一的异步通信机制，可以看做是异步通知，通知接收信号的进程有哪些事情发生了。信号同时又是一种软件中断，当某进程接收到信号时，会中止当前程序的执行，去处理信号的注册函数，然后回到断点程序继续往下执行。

进程能对每一个信号设置独立的处理方式：它能忽略该信号，也能设置相应的信号处理程序(称为捕捉)，或对信号什么也不做，信号发生的时候执行系统的默认动作。

所有的信号中，有两个信号(SIGSTOP和SIGKILL)是特别的，它们既不能被捕捉，也不能被忽略，也不能被阻塞，这个特性确保了系统管理员在所有时候内都能用暂停信号和杀死信号结束某个进程。

不可靠信号是指信号值小于32的信号。可靠信号是指后来添加的新信号(信号值位于32及64之间)。信号的可靠与不可靠只与信号值有关，与信号的发送及安装函数无关。非实时信号都不支持排队，都是不可靠信号；实时信号都支持排队，都是可靠信号。

现在在Linux系统中，不可靠信号和可靠信号的区别在于前者不支持排队，可能会造成信号的丢失，而后者不会。

内核为进程产生信号，来说明不同的事件，这些事件就是信号源。主要的信号源有：(1)、异常：进程运行过程中出现的异常；(2)、其它进程：一个进程可以向另外一个或一组进程发送信号；(3)、终端中断：Ctrl+C等；(4)、作业控制：前台、后台进程的管理；(5)、分配额：CPU超时或文件大小突破限制；(6)、通知：通知进程某事件发生，如I/O就绪等；(7)、报警：计时器到期。

信号的三种操作方式：忽略此信号、捕捉喜欢、执行系统的默认动作。

信号的5种默认动作：异常终止(abort)、退出(exit)、忽略(ignore)、停止(stop)、继续(continue)。

阻塞信号允许信号被发送给进程，但不进行处理，需要等到阻塞解除后再处理。而忽略信号是进程根本不接收该信号，所有被忽略的信号都被简单丢弃。

kill函数可以向有用户权限的任何进程发送信号，通常用kill函数来结束进程。与kill函数不同的是，raise函数只向进程自身发送信号。使用alarm函数可以设置一个时间值(闹钟时间)，在将来的某个时刻该时间值超过时发送信号。pause函数使调用进程挂起直至捕捉到一个信号。

信号是与一定的进程相联系的。也就是说，一个进程可以决定在进程中对哪些信号进行什么样的处理。

signal函数，有两个形参，分别代表需要处理的信号编号值和处理信号函数的指针。它主要是用于前32种非实时信号的处理，不支持信号的传递信息。

sigaction函数用来查询和设置信号处理方式，它是用来替换早期的signal函数。

信号集用来描述一类信号的集合，Linux所支持的信号可以全部或部分的出现在信号集中。信号集操作函数最常用的地方就是用于信号屏蔽。

信号量与其他进程间通信的方式不大相同，它主要提供对进程间共享资源访问控制机制，相当于内存中的标志，进程可以根据它判定是否能够访问某些共享资源，从而实现多个进程对某些共享资源的互斥访问；同时，进程也可以修改该标志。信号量除了用于访问控制外，还可用于进程同步。

test_signal1.cpp：

 

1. //信号的使用  
2. #include <unistd.h>  
3. #include <signal.h>  
4. #include <stdio.h>  
5.   
6. typedef void (*signal_handler)(int);  
7.   
8. void signal_handler_fun(int signal_num) /*信号处理函数*/  
9. {   
10.     printf("catch signal %d\n", signal_num);  
11. }  
12.   
13. int main()  
14. {  
15.     int i;  
16.     int time ;  
17.     signal_handler p_signal = signal_handler_fun;  
18.     signal(SIGALRM, p_signal); /*注册SIGALRM信号处理方式*/  
19.     //alarm()用来设置信号SIGALRM在经过参数seconds指定的秒数后传送给目前的进程  
20.     alarm(3);  
21.     for (i=1; i<5; i++) {  
22.         printf("sleep %d ...\n", i);  
23.         sleep(1);  
24.     }  
25.       
26.     alarm(3);  
27.     sleep(2);  
28.     time=alarm(0); /*取消SIGALRM信号，返回剩余秒数*/  
29.     printf("time=%d\n", time);  
30.       
31.     for (i=1; i<3; i++) {  
32.         printf("sleep %d ...\n", i);  
33.         sleep(1);  
34.     }  
35.       
36.     return 0 ;  
37. }  

test_signal2.cpp：

 

 

1. //信号的使用：父进程发信号给子进程  
2. #include <stdio.h>  
3. #include <unistd.h>  
4. #include <signal.h>  
5. #include <sys/types.h>  
6. #include <sys/wait.h>  
7.   
8. int main()  
9. {  
10.     pid_t pid;  
11.     int status;  
12.     pid = fork() ;  
13.     if (0 == pid) {  
14.         printf("Hi I am child process!\n");  
15.         sleep(10);  
16.     } else if (pid > 0) {  
17.         printf("send signal to child process (%d) \n", pid);  
18.         sleep(1);  
19.         //kill函数是将信号发送给指定的pid进程  
20.         /*发送SIGABRT信号给子进程，此信号引起接收进程异常终止*/  
21.         kill(pid ,SIGABRT);  
22.         /*等待子进程返回终止信息*/  
23.         wait(&status);  
24.           
25.         if(WIFSIGNALED(status))  
26.             printf("child process receive signal %d\n", WTERMSIG(status));  
27.     } else {  
28.         perror("fork error") ;  
29.         return -1 ;  
30.     }  
31.       
32.     return 0 ;  
33. }  

test_signal3.cpp：

1. //信号的使用  
2. //运行时，需要按：Ctrl+C或Ctrl+\  
3. #include <signal.h>  
4. #include <stdio.h>  
5. #include <stdlib.h>  
6. #include<unistd.h>  
7.   
8. /*自定义信号处理函数*/  
9. void my_func(int sign_no)  
10. {  
11.     if (sign_no == SIGINT)  
12.         printf("I have get SIGINT\n");  
13.     else if (sign_no == SIGQUIT)  
14.         printf("I have get SIGQUIT\n");  
15. }  
16.   
17. int main()  
18. {  
19.     printf("Waiting for signal SIGINT or SIGQUIT \n ");  
20.     /*发出相应的信号，并跳转到信号处理函数处*/  
21.     signal(SIGINT, my_func);  
22.     signal(SIGQUIT, my_func);  
23.       
24.     pause();  
25.     pause();  
26.     exit(0);  
27. }  

test_signal4.cpp：

 

 

1. //信号的使用：sigaction函数  
2. //此测试程序有段错误  
3. #include <stdio.h>  
4. #include <stdlib.h>  
5. #include <signal.h>  
6. #include <sys/types.h>  
7. #include <unistd.h>  
8.   
9. void new_op(int, siginfo_t *, void *);  
10.   
11. int main(int argc, char** argv)  
12. {  
13.     struct sigaction act;  
14.     int sig;  
15.     sig = atoi(argv[1]);  
16.     sigemptyset(&act.sa_mask);  
17.     act.sa_flags = SA_SIGINFO;  
18.     act.sa_sigaction = new_op;  
19.       
20.     if (sigaction(sig, &act, NULL) < 0) {  
21.         perror("install sigal error");  
22.         return -1 ;  
23.     }  
24.       
25.     while(1) {  
26.         sleep(2);  
27.         printf("wait for the signal\n");  
28.     }  
29.       
30.     return 0 ;  
31. }  
32.   
33. void new_op(int signum, siginfo_t *info, void *myact)  
34. {  
35.     printf("receive signal %d\n", signum);  
36.     sleep(5);  
37. }  

test_signal5.cpp：

1. //信号集函数的使用，需要Ctrl+C和Ctrl+\的参与  
2. #include <sys/types.h>  
3. #include <unistd.h>  
4. #include <signal.h>  
5. #include <stdio.h>  
6. #include <stdlib.h>  
7.   
8. /*自定义的信号处理函数*/  
9. #if 0  
10. void my_funcnew(int signum, siginfo_t *info, void *myact);  
11. #endif  
12.   
13. void my_func(int signum)  
14. {  
15.     printf("If you want to quit, please try SIGQUIT\n");  
16. }  
17.   
18. int main()  
19. {  
20.     sigset_t set, pendset;  
21.     struct sigaction action1, action2;  
22.       
23.     /*设置信号处理方式*/  
24.     sigemptyset(&action1.sa_mask);  
25.       
26. #if 0 /*信号新的安装机制*/  
27.     action1.sa_flags = SA_SIGINFO;  
28.     action1.sa_sigaction = my_funcnew;  
29. #endif  
30.     /*信号旧的安装机制*/  
31.     action1.sa_flags = 0;  
32.     action1.sa_handler = my_func;  
33.     sigaction(SIGINT, &action1, NULL);  
34.       
35.     /*初始化信号集为空*/  
36.     if (sigemptyset(&set) < 0) {  
37.         perror("sigemptyset");  
38.         return -1 ;  
39.     }  
40.     /*将相应的信号加入信号集*/  
41.     if (sigaddset(&set, SIGQUIT) < 0) {  
42.         perror("sigaddset");  
43.         return -1 ;  
44.     }  
45.     if (sigaddset(&set, SIGINT) < 0) {  
46.         perror("sigaddset");  
47.         return -1 ;  
48.     }  
49.       
50.     /*设置信号集屏蔽字*/  
51.     if (sigprocmask(SIG_BLOCK, &set, NULL) < 0) {  
52.         perror("sigprocmask");  
53.         return -1 ;  
54.     } else {  
55.         printf("blocked\n");  
56.     }  
57.       
58.     /*测试信号是否加入该信号集*/  
59.     if (sigismember(&set, SIGINT)) {  
60.         printf("SIGINT in set\n") ;  
61.     }  
62.       
63.     sleep(30);  
64.     /*测试未决信号*/  
65.     if (sigpending(&pendset) <0) {  
66.         perror("get pending mask error");  
67.     }  
68.     if (sigismember(&pendset, SIGINT)) {  
69.         printf("signal SIGINT is pending\n");  
70.     }  
71.       
72.     sleep(30) ;  
73.     if (sigprocmask(SIG_UNBLOCK, &set,NULL) < 0) {  
74.         perror("sigprocmask");  
75.         return -1 ;  
76.     } else {  
77.         printf("unblock\n");  
78.     }  
79.       
80.     while(1) {  
81.         sleep(1) ;  
82.     }  
83.       
84.     return 0 ;  
85. }  

 

共享内存区域是被多个进程共享的一部分物理内存。如果多个进程都把该内存区域映射到自己的虚拟地址空间，则这些进程就都可以直接访问该共享内存区域，从而可以通过该区域进行通信。共享内存是进程间共享数据的一种最快的方法，一个进程向共享内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容。这块共享虚拟内存的页面，出现在每一个共享该页面的进程的页表中。

注：以上内容及测试代码整理自网络。