Linux下的多进程编程初步

• Linux下的多进程编程初步
  • 多进程编程
    • 1 Linux下进程的结构
    • 2 Linux下的进程控制
      • 21 僵尸进程
      • 22 fork
      • 23 exec 函数族
    • 3 Linux下的进程间通信
      • 31 管道
        • 无名管道
        • 有名管道
      • 32 消息队列
      • 33 共享内存
        • shmget函数
        • shmat函数
        • shmdt函数
        • shmctl函数
        • 使用共享内存进行进程间通信
        • 使用共享内存的优缺点
      • 34 信号量
      • 35 套接口
  • Linux的进程和Win32的进程线程比较

2. 多进程编程

什么是一个进程？进程这个概念是针对系统而不是针对用户的，对用户来说，他面对的概念是程序。当用户敲入命令执行一个程序的时候，对系统而言，它将启动一个进程。但和程序不同的是，在这个进程中，系统可能需要再启动一个或多个进程来完成独立的多个任务。多进程编程的主要内容包括进程控制和进程间通信，在了 解这些之前，我们先要简单知道进程的结构。

2.1 Linux下进程的结构

　　 Linux下一个进程在内存里有三部分的数据，就是”代码段”、”堆栈段”和”数据段”。其实学过汇编语言的人一定知道，一般的CPU都有上述三种段寄存器，以方便操作系统的运行。这三个部分是构成一个完整的执行序列的必要的部分。”代码段”，顾名思义，就是存放了程序代码的数据，假如机器中有数个进程运行相同的一个程序，那么它们就可以使用相同的代码段。”堆栈段”存放的就是子程 序的返回地址、子程序的参数以及程序的局部变量。而数据段则存放程序的全局变量，常数以及动态数据分配的数据空间（比如用malloc之类的函数取得的空间）。这其中有许多细节问题，这里限于篇幅就不多介绍了。系统如果同时运行数个相同的程序，它们之间就不能使用同一个堆栈段和数据段。

2.2 Linux下的进程控制

在传统的Unix环境下，有两个基本的操作用于创建和修改进程：函数fork()用来创建一个新的进程，该进程几乎是当前进程的一个完全拷贝；函数族exec()用来启动另外的进程以取代当前运行的进程。Linux的进程控制和传统的Unix进程控制基本一致，只在一些细节的地方有些区别，例如在Linux系统 中调用vfork和fork完全相同，而在有些版本的Unix系统中，vfork调用有不同的功能。由于这些差别几乎不影响我们大多数的编程，在这里我们 不予考虑。

2.2.1 僵尸进程

子进程在执行结束的时候会释放占有的内存，文件。但是会保留一定的信息（如PID，退出状态，运行时间等），直到父进程wait/waitpid来索取之后才释放。如果没有索取会一直保留，这就导致进程号被一直占用，残留的状态叫做僵尸进程。

僵尸进程的避免

1. 父进程通过wait和waitpid等函数等待子进程结束，这会导致父进程挂起。
2. 如果父进程很忙，那么可以用signal函数为SIGCHLD安装handler，因为子进程结束后，父进程会收到该信号，可以在handler中调用wait回收。
3. 如果父进程不关心子进程什么时候结束，那么可以用signal（SIGCHLD,SIG_IGN） 通知内核，自己对子进程的结束不感兴趣，那么子进程结束后，内核会回收，并不再给父进程发送信号。
4. 还有一些技巧，就是fork两次，父进程fork一个子进程，然后继续工作，子进程fork一个孙进程后退出，那么孙进程被init接管，孙进程结束后，init会回收。不过子进程的回收还要自己做。

2.2.2 fork

fork在英文中是”分叉”的意思。为什么取这个名字呢？因为一个进程在运行中，如果使用了fork，就产生了另一个进程，于是进程就”分叉”了，所以这个名字取得很形象。fork()有两个返回值或者一个返回值（出错时候），在父进程fork返回子进程id，子进程返回0.利用getpid可以查看当前进程id，getppid查看父进程id，但在子进程中getppid返回的是1。

2.2.3 exec( )函数族

下面我们来看看一个进程如何来启动另一个程序的执行。在Linux中要使用exec函数族。系统调用execve（）对当前进程进行替换，替换者为一个指定的程序，其参数包括文件名（filename）、参数列表（argv）以及环境变量（envp）。exec函数族当然不止一个，但它们大致相同，在Linux中，它们分别是：execl，execlp，execle，execv，execve和execvp，下面我只以execlp为例，其它函数究 竟与execlp有何区别，请通过manexec命令来了解它们的具体情况。

一个进程一旦调用exec类函数，它本身就”死亡”了，系统把代码段替换成新的程序的代码，废弃原有的数据段和堆栈段，并为新程序分配新的数据段与堆栈段，唯一留下的，就是进程号，也就是说，对系统而言，还是同一个进程，不过已经是另一个程序了。（不过exec类函数中有的还允许继承环境变量之类的信 息。）

那么如果我的程序想启动另一程序的执行但自己仍想继续运行的话，怎么办呢？那就是结合fork与exec的使用。下面一段代码显示如何启动运行其它程序： 
　　

char  command[256];   void  main()   {   int  rtn;  /*子进程的返回数值*/    while (1) {   /* 从终端读取要执行的命令 */    printf(  ">"  );   fgets( command, 256, stdin );   command[strlen(command)-1] = 0;   if  ( fork() == 0 ) {   /* 子进程执行此命令 */    execlp( command, command );   /* 如果exec函数返回，表明没有正常执行命令，打印错误信息*/    perror( command );   exit( errorno );   }   else  {   /* 父进程， 等待子进程结束，并打印子进程的返回值 */    wait ( &rtn );   printf(  " child process return %d/n" ,. rtn );   }   }   }   char command[256];void main(){int rtn; /*子进程的返回数值*/while(1) {/* 从终端读取要执行的命令 */printf( ">" );fgets( command, 256, stdin );command[strlen(command)-1] = 0;if ( fork() == 0 ) {/* 子进程执行此命令 */execlp( command, command );/* 如果exec函数返回，表明没有正常执行命令，打印错误信息*/perror( command );exit( errorno );}else {/* 父进程， 等待子进程结束，并打印子进程的返回值 */wait ( &rtn );printf( " child process return %d/n",. rtn );}}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

此程序从终端读入命令并执行之，执行完成后，父进程继续等待从终端读入命令。DOS/WINDOWS也有exec类函数，其使用方法是类似的，但DOS/WINDOWS还有spawn类函数，因为DOS是单任务的系统，它只能将”父进程”驻留在机器内再执行”子进程”，这就是spawn类的函数。WIN32已经是多任务的系统了，但还保留了spawn类函数，WIN32中实现spawn函数的方法同前述UNIX中的方法差不多，开设子进程后父进程等待子进程结束后才继续运行。UNIX在其一开始就是多任务的系统，所以从核心角度上讲不需要spawn类函 数。

在这一节里，我们还要讲讲system（）和popen（）函数。system（）函数先调用fork（），然后再调用exec（）来执行用户的登录shell，通过它来查找可执行文件的命令并分析参数，最后它么使用wait（）函数族之一来等待子进程的结束。函数popen（）和函数system（）相似，不同的是它调用pipe（）函数创建一个管道，通过它来完成程序的标准输入和标准输出。这两个函数是为那些不太勤快的程序员设计 的，在效率和安全方面都有相当的缺陷，在可能的情况下，应该尽量避免。

2.3 Linux下的进程间通信

详细的讲述进程间通信在这里绝对是不可能的事情，而且笔者很难有信心说自己对这一部分内容的认识达到了什么样的地步，所以在这一节的开头首先向大家推荐著名作者RichardStevens的著名作品：《Advanced Programming in the UNIXEnvironment》 ,它的中文译本《UNIX环境高级编程》已有机械工业出版社出版，原文精彩，译文同样地道，如果你的确对在Linux下编程有浓厚的兴趣，那么赶紧将这本书摆到你的书桌上或计算机旁边来。说这么多实在是难抑心中的景仰之情，言归正传，在这一节里，我们将介绍进程间通信最最初步和最 最简单的一些知识和概念。

首先，进程间通信至少可以通过传送打开文件来实现，不同的进程通过一个或多个文件来传递信息，事实上，在很多应用系统里，都使用了这种方法。但一般说来，进程间通信（IPC：InterProcess Communication）不包括这种似乎比较低级的通信方法。Unix系统中实现进程间通信的方法很多，而且不幸的是，极少方法能在所有的Unix系统中进行移植（唯一一种是半双工的管道，这也是最原始的一种通信方式）。而Linux作为一种新兴的操作系统，几乎支持所有的Unix下常用的进程间通信 方法：管道、消息队列、共享内存、信号量、套接口等等。下面我们将逐一介绍。

2.3.1 管道

无名管道

　　 管道是进程间通信中最古老的方式，它包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者用于运行于同一台机器上的任意两个进程间的通信。

无名管道由pipe（）函数创建：

#include “unistd.h” 
int pipe(int filedis[2])； 
参数filedis返回两个文件描述符：filedes[0]为读而打开，filedes[1]为写而打开。filedes[1]的输出是filedes[0]的输入。下面的例子示范了如何在父进程和子进程间实现通信。

#define INPUT 0    #define OUTPUT 1    void  main() {   int  file_descriptors[2];   /*定义子进程号 */    pid_t pid;   char  buf[256];   int  returned_count;   /*创建无名管道*/    pipe(file_descriptors);   /*创建子进程*/    if ((pid = fork()) == -1) {   printf( "Error in fork/n" );   exit(1);   }   /*执行子进程*/    if (pid == 0) {   printf( "in the spawned (child) process.../n" );   /*子进程向父进程写数据，关闭管道的读端*/    close(file_descriptors[INPUT]);   write(file_descriptors[OUTPUT],  "test data" , strlen( "test data" ));   exit(0);   }  else  {   /*执行父进程*/    printf( "in the spawning (parent) process.../n" );   /*父进程从管道读取子进程写的数据，关闭管道的写端*/    close(file_descriptors[OUTPUT]);   returned_count = read(file_descriptors[INPUT], buf,  sizeof (buf));   printf( "%d bytes of data received from spawned process: %s/n" ,   returned_count, buf);   }   }   #define INPUT 0#define OUTPUT 1void main() {int file_descriptors[2];/*定义子进程号 */pid_t pid;char buf[256];int returned_count;/*创建无名管道*/pipe(file_descriptors);/*创建子进程*/if((pid = fork()) == -1) {printf("Error in fork/n");exit(1);}/*执行子进程*/if(pid == 0) {printf("in the spawned (child) process.../n");/*子进程向父进程写数据，关闭管道的读端*/close(file_descriptors[INPUT]);write(file_descriptors[OUTPUT], "test data", strlen("test data"));exit(0);} else {/*执行父进程*/printf("in the spawning (parent) process.../n");/*父进程从管道读取子进程写的数据，关闭管道的写端*/close(file_descriptors[OUTPUT]);returned_count = read(file_descriptors[INPUT], buf, sizeof(buf));printf("%d bytes of data received from spawned process: %s/n",returned_count, buf);}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

有名管道

int mkfifo(const char *pathname, mode_t mode) 
pathname: FIFO文件名 
mode: 属性 
创建成功返回值大于0，一旦创建了了FIFO，就可open去打开它，可以使用open，read，close等去操作FIFO 
当打开FIFO时，非阻塞标志（O_NONBLOCK）将会对读写产生如下影响： 
1. 没有使用O_NONBLOCK：访问要求无法满足时进程将阻塞。如试图读取空的FIFO，将导致进程阻塞； 
1. 使用O_NONBLOCK：访问要求无法满足时不阻塞，立即出错返回，errno是ENXIO；

读管道example： #include <stdio.h>  #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <string.h> #include <stdlib.h> #define P_FIFO         "/tmp/p_fifo" int main(int argc, char** argv){         char cache[100];         int fd;         memset(cache,0, sizeof(cache));                             //初始化内存         if(access(P_FIFO,F_OK)==0){                                 //管道文件存在                   execlp("rm","-f", P_FIFO, NULL);                  //删掉                   printf("access.\n");         }         if(mkfifo(P_FIFO, 0777) < 0){                              printf("createnamed pipe failed.\n");         }         fd= open(P_FIFO,O_RDONLY|O_NONBLOCK);        //     非阻塞方式打开，只读         while(1){                                                                             //     一直去读                   memset(cache,0, sizeof(cache));                   if((read(fd,cache, 100)) == 0 ){                           //     没有读到数据                            printf("nodata:\n");                   }                   else                            printf("getdata:%s\n", cache);                //     读到数据，将其打印                            sleep(1); //休眠1s         }         close(fd);         return0;}写管道example： #include <stdio.h> #include <fcntl.h> #include <unistd.h> #define P_FIFO "/tmp/p_fifo" int main(int argc, char argv[]){          intfd;         if(argc< 2){                   printf("pleaseinput the write data.\n");         }         fd= open(P_FIFO,O_WRONLY|O_NONBLOCK);                //非阻塞方式         write(fd,argv[1], 100);                                                            //将argv[1]写道fd里面去         close(fd);}测试：root--> ./mkfifo_rno data:no data:get data:linuxdbano data:no data:no data:no data:no data:......
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

2.3.2 消息队列

　　 消息队列用于运行于同一台机器上的进程间通信，它和管道很相似，事实上，它是一种正逐渐被淘汰的通信方式，我们可以用流管道或者套接口的方式来取代它，所以，我们对此方式也不再解释，也建议读者忽略这种方式。

2.3.3 共享内存

1. shmget函数

共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。得到共享内存有两种方式：映射/dev/mem设备和内存映像文件。前一种方式不给系统带来额外的开销，但在现实中并不常用，因为它控制存取的将是实际的物理内存，在Linux系统下，这只有通过限制Linux系统存取的内存才可以做到，这当然不太实际。常用的方式是通过shmXXX函数族来实现利 用共享内存进行存储的。 
首先要用的函数是shmget，它获得一个共享存储标识符。

#include <sys/types.h>#include <sys/ipc.h>#include <sys/shm.h>int shmget(key_t key, int size, int flag);
1
2
3
4
1
2
3
4

• 程序需要提供一个参数key（非0整数），它有效地为共享内存段命名，shmget函数成功时返回一个与key相关的共享内存标识符（非负整数），用于后续的共享内存函数。调用失败返回-1.

不相关的进程可以通过该函数的返回值访问同一共享内存，它代表程序可能要使用的某个资源，程序对所有共享内存的访问都是间接的，程序先通过调用shmget函数并提供一个键，再由系统生成一个相应的共享内存标识符（shmget函数的返回值），只有shmget函数才直接使用信号量键，所有其他的信号量函数使用由semget函数返回的信号量标识符。

• 第二个参数，size以字节为单位指定需要共享的内存容量

• 第三个参数，shmflg是权限标志，它的作用与open函数的mode参数一样，如果要想在key标识的共享内存不存在时，创建它的话，可以与IPC_CREAT做或操作。共享内存的权限标志与文件的读写权限一样，举例来说，0644,它表示允许一个进程创建的共享内存被内存创建者所拥有的进程向共享内存读取和写入数据，同时其他用户创建的进程只能读取共享内存。

2. shmat函数

第一次创建完共享内存时，它还不能被任何进程访问，shmat函数的作用就是用来启动对该共享内存的访问，并把共享内存连接到当前进程的地址空间。它的原型如下：

    void *shmat(int shm_id, const void *shm_addr, int shmflg);  
1
1

• 第一个参数，shm_id是由shmget函数返回的共享内存标识。
• 第二个参数，shm_addr指定共享内存连接到当前进程中的地址位置，通常为空，表示让系统来选择共享内存的地址。
• 第三个参数，shm_flg是一组标志位，通常为0。

调用成功时返回一个指向共享内存第一个字节的指针，如果调用失败返回-1.

3. shmdt函数

该函数用于将共享内存从当前进程中分离。注意，将共享内存分离并不是删除它，只是使该共享内存对当前进程不再可用。它的原型如下：

    int shmdt(const void *shmaddr);  
1
1

参数shmaddr是shmat函数返回的地址指针，调用成功时返回0，失败时返回-1.

4. shmctl函数

与信号量的semctl函数一样，用来控制共享内存，它的原型如下：

    int shmctl(int shm_id, int command, struct shmid_ds *buf);  
1
1

• 第一个参数，shm_id是shmget函数返回的共享内存标识符。

• 第二个参数，command是要采取的操作，它可以取下面的三个值 ：

• • IPC_STAT：把shmid_ds结构中的数据设置为共享内存的当前关联值，即用共享内存的当前关联值覆盖shmid_ds的值。
• • IPC_SET：如果进程有足够的权限，就把共享内存的当前关联值设置为shmid_ds结构中给出的值
• • IPC_RMID：删除共享内存段

• 第三个参数，buf是一个结构指针，它指向共享内存模式和访问权限的结构。 
  shmid_ds结构至少包括以下成员：

    struct shmid_ds      {          uid_t shm_perm.uid;          uid_t shm_perm.gid;          mode_t shm_perm.mode;      };  
1
2
3
4
5
6
1
2
3
4
5
6

5. 使用共享内存进行进程间通信

下面就以两个不相关的进程来说明进程间如何通过共享内存来进行通信。其中一个文件shmread.c创建共享内存，并读取其中的信息，另一个文件shmwrite.c向共享内存中写入数据。为了方便操作和数据结构的统一，为这两个文件定义了相同的数据结构，定义在文件shmdata.c中。结构shared_use_st中的written作为一个可读或可写的标志，非0：表示可读，0表示可写，text则是内存中的文件。

shmdata.h的源代码如下：

#ifndef _SHMDATA_H_HEADER  #define _SHMDATA_H_HEADER  #define TEXT_SZ 2048  struct shared_use_st  {      int written;//作为一个标志，非0：表示可读，0表示可写      char text[TEXT_SZ];//记录写入和读取的文本  };  #endif  
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

源文件shmread.c的源代码如下：

#include <unistd.h>  #include <stdlib.h>  #include <stdio.h>  #include <sys/shm.h>  #include "shmdata.h"  int main()  {      int running = 1;//程序是否继续运行的标志      void *shm = NULL;//分配的共享内存的原始首地址      struct shared_use_st *shared;//指向shm      int shmid;//共享内存标识符      //创建共享内存      shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666|IPC_CREAT);      if(shmid == -1)      {          fprintf(stderr, "shmget failed\n");          exit(EXIT_FAILURE);      }      //将共享内存连接到当前进程的地址空间      shm = shmat(shmid, 0, 0);      if(shm == (void*)-1)      {          fprintf(stderr, "shmat failed\n");          exit(EXIT_FAILURE);      }      printf("\nMemory attached at %X\n", (int)shm);      //设置共享内存      shared = (struct shared_use_st*)shm;      shared->written = 0;      while(running)//读取共享内存中的数据      {          //没有进程向共享内存定数据有数据可读取          if(shared->written != 0)          {              printf("You wrote: %s", shared->text);              sleep(rand() % 3);              //读取完数据，设置written使共享内存段可写              shared->written = 0;              //输入了end，退出循环（程序）              if(strncmp(shared->text, "end", 3) == 0)                  running = 0;          }          else//有其他进程在写数据，不能读取数据              sleep(1);      }      //把共享内存从当前进程中分离      if(shmdt(shm) == -1)      {          fprintf(stderr, "shmdt failed\n");          exit(EXIT_FAILURE);      }      //删除共享内存      if(shmctl(shmid, IPC_RMID, 0) == -1)      {          fprintf(stderr, "shmctl(IPC_RMID) failed\n");          exit(EXIT_FAILURE);      }      exit(EXIT_SUCCESS);  }  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

源文件shmwrite.c的源代码如下：

#include <unistd.h>  #include <stdlib.h>  #include <stdio.h>  #include <string.h>  #include <sys/shm.h>  #include "shmdata.h"  int main()  {      int running = 1;      void *shm = NULL;      struct shared_use_st *shared = NULL;      char buffer[BUFSIZ + 1];//用于保存输入的文本      int shmid;      //创建共享内存      shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666|IPC_CREAT);      if(shmid == -1)      {          fprintf(stderr, "shmget failed\n");          exit(EXIT_FAILURE);      }      //将共享内存连接到当前进程的地址空间      shm = shmat(shmid, (void*)0, 0);      if(shm == (void*)-1)      {          fprintf(stderr, "shmat failed\n");          exit(EXIT_FAILURE);      }      printf("Memory attached at %X\n", (int)shm);      //设置共享内存      shared = (struct shared_use_st*)shm;      while(running)//向共享内存中写数据      {          //数据还没有被读取，则等待数据被读取,不能向共享内存中写入文本          while(shared->written == 1)          {              sleep(1);              printf("Waiting...\n");          }          //向共享内存中写入数据          printf("Enter some text: ");          fgets(buffer, BUFSIZ, stdin);          strncpy(shared->text, buffer, TEXT_SZ);          //写完数据，设置written使共享内存段可读          shared->written = 1;          //输入了end，退出循环（程序）          if(strncmp(buffer, "end", 3) == 0)              running = 0;      }      //把共享内存从当前进程中分离      if(shmdt(shm) == -1)      {          fprintf(stderr, "shmdt failed\n");          exit(EXIT_FAILURE);      }      sleep(2);      exit(EXIT_SUCCESS);  }  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

分析：

1、程序shmread创建共享内存，然后将它连接到自己的地址空间。在共享内存的开始处使用了一个结构struct_use_st。该结构中有个标志written，当共享内存中有其他进程向它写入数据时，共享内存中的written被设置为0，程序等待。当它不为0时，表示没有进程对共享内存写入数据，程序就从共享内存中读取数据并输出，然后重置设置共享内存中的written为0，即让其可被shmwrite进程写入数据。

2、程序shmwrite取得共享内存并连接到自己的地址空间中。检查共享内存中的written，是否为0，若不是，表示共享内存中的数据还没有被完，则等待其他进程读取完成，并提示用户等待。若共享内存的written为0，表示没有其他进程对共享内存进行读取，则提示用户输入文本，并再次设置共享内存中的written为1，表示写完成，其他进程可对共享内存进行读操作。

• 关于前面的例子的安全性讨论 
  这个程序是不安全的，当有多个程序同时向共享内存中读写数据时，问题就会出现。可能你会认为，可以改变一下written的使用方式，例如，只有当written为0时进程才可以向共享内存写入数据，而当一个进程只有在written不为0时才能对其进行读取，同时把written进行加1操作，读取完后进行减1操作。这就有点像文件锁中的读写锁的功能。咋看之下，它似乎能行得通。但是这都不是原子操作，所以这种做法是行不能的。试想当written为0时，如果有两个进程同时访问共享内存，它们就会发现written为0，于是两个进程都对其进行写操作，显然不行。当written为1时，有两个进程同时对共享内存进行读操作时也是如些，当这两个进程都读取完是，written就变成了-1.

要想让程序安全地执行，就要有一种进程同步的进制，保证在进入临界区的操作是原子操作。例如，可以使用前面所讲的信号量来进行进程的同步。因为信号量的操作都是原子性的。

6.使用共享内存的优缺点

1、优点：我们可以看到使用共享内存进行进程间的通信真的是非常方便，而且函数的接口也简单，数据的共享还使进程间的数据不用传送，而是直接访问内存，也加快了程序的效率。同时，它也不像匿名管道那样要求通信的进程有一定的父子关系。

2、缺点：共享内存没有提供同步的机制，这使得我们在使用共享内存进行进程间通信时，往往要借助其他的手段来进行进程间的同步工作。

2.3.4 信号量

信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是前一节的共享内存方式的进程间通信。本质上，信号量是一个计数器，它用来记录对某个资源（如共享内存）的存取状况。一般说来，为了获得共享资源，进程需要执行下列操作：

测试控制该资源的信号量。 
1. 若此信号量的值为正，则允许进行使用该资源。进程将进号量减1。 
1. 若此信号量为0，则该资源目前不可用，进程进入睡眠状态，直至信号量值大于0，进程被唤醒，转入步骤（1）。 
1. 当进程不再使用一个信号量控制的资源时，信号量值加1。如果此时有进程正在睡眠等待此信号量，则唤醒此进程。

维护信号量状态的是Linux内核操作系统而不是用户进程。我们可以从头文件”/usr/src/linux/include/linux/sem.h“” 中看到内核用来维护信号量状态的各个结构的定义。信号量是一个数据集合，用户可以单独使用这一集合的每个元素。要调用的第一个函数是semget，用以获 得一个信号量ID。

#include <sys/types.h>    　　 #include <sys/ipc.h>   　　 #include <sys/sem.h>   　　  int  semget(key_t key,  int  nsems,  int  flag);   #include <sys/types.h>　　 #include <sys/ipc.h>　　 #include <sys/sem.h>　　 int semget(key_t key, int nsems, int flag);
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

key是前面讲过的IPC结构的关键字，它将来决定是创建新的信号量集合，还是引用一个现有的信号量集合。nsems是该集合中的信号量数。如果是创建新集合（一般在服务器中），则必须指定nsems；如果是引用一个现有的信号量集合（一般在客户机中）则将nsems指定为0。semctl函数用来对信号量进行操作。

　　 int semctl(int semid, int semnum, int cmd, union semun arg);
1
1

不同的操作是通过cmd参数来实现的，在头文件sem.h中定义了7种不同的操作，实际编程时可以参照使用。semop函数自动执行信号量集合上的操作数组。

int semop(int semid, struct sembuf semoparray[], size_t nops);
1
1

semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。

下面，我们看一个具体的例子，它创建一个特定的IPC结构的关键字和一个信号量，建立此信号量的索引，修改索引指向的信号量的值，最后我们清除信号量。在下面的代码中，函数ftok生成我们上文所说的唯一的IPC关键字。

#include <stdio.h>    #include <sys/types.h>    #include <sys/sem.h>    #include <sys/ipc.h>    void  main() {   key_t unique_key;  /* 定义一个IPC关键字*/    int  id;   struct  sembuf lock_it;   union  semun options;   int  i;   unique_key = ftok( "." ,  'a' );  /* 生成关键字，字符'a'是一个随机种子*/    /* 创建一个新的信号量集合*/    id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666);   printf( "semaphore id=%d/n" , id);   options.val = 1;  /*设置变量值*/    semctl(id, 0, SETVAL, options);  /*设置索引0的信号量*/    /*打印出信号量的值*/    i = semctl(id, 0, GETVAL, 0);   printf( "value of semaphore at index 0 is %d/n" , i);   /*下面重新设置信号量*/    lock_it.sem_num = 0;  /*设置哪个信号量*/    lock_it.sem_op = -1;  /*定义操作*/    lock_it.sem_flg = IPC_NOWAIT;  /*操作方式*/    if  (semop(id, &lock_it, 1) == -1) {   printf( "can not lock semaphore./n" );   exit(1);   }   i = semctl(id, 0, GETVAL, 0);   printf( "value of semaphore at index 0 is %d/n" , i);   /*清除信号量*/    semctl(id, 0, IPC_RMID, 0);   }   #include <stdio.h>#include <sys/types.h>#include <sys/sem.h>#include <sys/ipc.h>void main() {key_t unique_key; /* 定义一个IPC关键字*/int id;struct sembuf lock_it;union semun options;int i;unique_key = ftok(".", 'a'); /* 生成关键字，字符'a'是一个随机种子*//* 创建一个新的信号量集合*/id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666);printf("semaphore id=%d/n", id);options.val = 1; /*设置变量值*/semctl(id, 0, SETVAL, options); /*设置索引0的信号量*//*打印出信号量的值*/i = semctl(id, 0, GETVAL, 0);printf("value of semaphore at index 0 is %d/n", i);/*下面重新设置信号量*/lock_it.sem_num = 0; /*设置哪个信号量*/lock_it.sem_op = -1; /*定义操作*/lock_it.sem_flg = IPC_NOWAIT; /*操作方式*/if (semop(id, &lock_it, 1) == -1) {printf("can not lock semaphore./n");exit(1);}i = semctl(id, 0, GETVAL, 0);printf("value of semaphore at index 0 is %d/n", i);/*清除信号量*/semctl(id, 0, IPC_RMID, 0);}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

2.3.5 套接口

套接口（socket）编程是实现Linux系统和其他大多数操作系统中进程间通信的主要方式之一。我们熟知的WWW服务、FTP服务、TELNET服务等都是基于套接口编程来实现的。除了在异地的计算机进程间以外，套接口同样适用于本地同一台计算机内部的进程间通信。关于套接口的经典教材同样是 Richard Stevens编著的《Unix网络编程：联网的API和套接字》，清华大学出版社出版了该书的影印版。它同样是Linux程序员的必备书籍之一。

关于这一部分的内容，可以参照本文作者的另一篇文章《设计自己的网络蚂蚁》，那里由常用的几个套接口函数的介绍和示例程序。这一部分或许是Linux进程间通信编程中最须关注和最吸引人的一部分，毕竟，Internet 正在我们身边以不可思议的速度发展着，如果一个程序员在设计编写他下一个程序的时候，根本没有考虑到网络，考虑到Internet，那么，可以说，他的设 计很难成功。

3 Linux的进程和Win32的进程/线程比较

熟悉WIN32编程的人一定知道，WIN32的进程管理方式与Linux上有着很大区别，在UNIX里，只有进程的概念，但在WIN32里却还有一个”线程”的概念，那么Linux和WIN32在这里究竟有着什么区别呢？ 
WIN32里的进程/线程是继承自OS/2的。在WIN32里，”进程”是指一个程序，而”线程”是一个”进程”里的一个执行”线索”。从核心上讲，WIN32的多进程与Linux并无多大的区别，在WIN32里的线程才相当于Linux的进程，是一个实际正在执行的代码。但是，WIN32里同一个进程里各个线程之间是共享数据段的。这才是与Linux的进程最大的不同。

下面这段程序显示了WIN32下一个进程如何启动一个线程。

int  g;   DWORD  WINAPI ChildProcess(  LPVOID  lpParameter ){   int  i;   for  ( i = 1; i <1000; i ++) {   g ++;   printf(  "This is Child Thread: %d/n" , g );   }   ExitThread( 0 );   };   void  main()   {   int  threadID;   int  i;   g = 0;   CreateThread( NULL, 0, ChildProcess, NULL, 0, &threadID );   for  ( i = 1; i <1000; i ++) {   g ++;   printf(  "This is Parent Thread: %d/n" , g );   }   }   int g;DWORD WINAPI ChildProcess( LPVOID lpParameter ){int i;for ( i = 1; i <1000; i ++) {g ++;printf( "This is Child Thread: %d/n", g );}ExitThread( 0 );};void main(){int threadID;int i;g = 0;CreateThread( NULL, 0, ChildProcess, NULL, 0, &threadID );for ( i = 1; i <1000; i ++) {g ++;printf( "This is Parent Thread: %d/n", g );}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

在WIN32下，使用CreateThread函数创建线程，与Linux下创建进程不同，WIN32线程不是从创建处开始运行的，而是由 CreateThread指定一个函数，线程就从那个函数处开始运行。此程序同前面的UNIX程序一样，由两个线程各打印1000条信息。threadID是子线程的线程号，另外，全局变量g是子线程与父线程共享的，这就是与Linux最大的不同之处。大家可以看出，WIN32的进程/线程要比Linux复杂，在Linux要实现类似WIN32的线程并不难，只要fork以后，让子进程调用ThreadProc函数，并且为全局变量开设共享 数据区就行了，但在WIN32下就无法实现类似fork的功能了。所以现在WIN32下的C语言 编译器所提供的库函数虽然已经能兼容大多数Linux/UNIX的库函数，但却仍无法实现fork。

对于多任务系统，共享数据区是必要的，但也是一个容易引起混乱的问题，在WIN32下，一个程序员很容易忘记线程之间的数据是共享的这一情况，一个线程修改过一个变量后，另一个线程却又修改了它，结果引起程序出问题。但在Linux下，由于变量本来并不共享，而由程序员来显式地指定要共享的数据，使程序变 得更清晰与安全。至于WIN32的”进程”概念，其含义则是”应用程序”，也就是相当于UNIX下的exec了。

Linux也有自己的多线程函数pthread，它既不同于Linux的进程，也不同于WIN32下的进程，关于pthread的介绍和如何在Linux环境下编写多线程程序我们将在另一篇文章《Linux下的多线程编程》中讲述。

参考连接： 

http://blog.csdn.net/ljianhui/article/details/10253345 

转载自：

linux 多进程 - Lester的博客 - 博客频道 - CSDN.NET
http://blog.csdn.net/u012266559/article/details/68067391?locationNum=8&fps=1