Linux进程间通信——使用共享内存(转)

这篇文章将讲述别一种进程间通信的机制——信号量。注意请不要把它与之前所说的信号混淆起来，信号与信号量是不同的两种事物。有关信号的更多内容，可以阅读我的另一篇文章：Linux进程间通信——使用信号。下面就进入信号量的讲解。

一、什么是信号量

为了防止出现因多个程序同时访问一个共享资源而引发的一系列问题，我们需要一种方法，它可以通过生成并使用令牌来授权，在任一时刻只能有一个执行线程访问代码的临界区域。临界区域是指执行数据更新的代码需要独占式地执行。而信号量就可以提供这样的一种访问机制，让一个临界区同一时间只有一个线程在访问它，也就是说信号量是用来调协进程对共享资源的访问的。

信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操作。最简单的信号量是只能取0和1的变量，这也是信号量最常见的一种形式，叫做二进制信号量。而可以取多个正整数的信号量被称为通用信号量。这里主要讨论二进制信号量。

二、信号量的工作原理

由于信号量只能进行两种操作等待和发送信号，即P(sv)和V(sv),他们的行为是这样的：

P(sv)：如果sv的值大于零，就给它减1；如果它的值为零，就挂起该进程的执行

V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给它加1.

举个例子，就是两个进程共享信号量sv，一旦其中一个进程执行了P(sv)操作，它将得到信号量，并可以进入临界区，使sv减1。而第二个进程将被阻止进入临界区，因为当它试图执行P(sv)时，sv为0，它会被挂起以等待第一个进程离开临界区域并执行V(sv)释放信号量，这时第二个进程就可以恢复执行。

三、Linux的信号量机制

Linux提供了一组精心设计的信号量接口来对信号进行操作，它们不只是针对二进制信号量，下面将会对这些函数进行介绍，但请注意，这些函数都是用来对成组的信号量值进行操作的。它们声明在头文件sys/sem.h中。

1、semget函数

它的作用是创建一个新信号量或取得一个已有信号量，原型为：

[cpp] view plain copy

print?

  1. int semget(key_t key, int num_sems, int sem_flags);

第一个参数key是整数值（唯一非零），不相关的进程可以通过它访问一个信号量，它代表程序可能要使用的某个资源，程序对所有信号量的访问都是间接的，程序先通过调用semget函数并提供一个键，再由系统生成一个相应的信号标识符（semget函数的返回值），只有semget函数才直接使用信号量键，所有其他的信号量函数使用由semget函数返回的信号量标识符。如果多个程序使用相同的key值，key将负责协调工作。

第二个参数num_sems指定需要的信号量数目，它的值几乎总是1。

第三个参数sem_flags是一组标志，当想要当信号量不存在时创建一个新的信号量，可以和值IPC_CREAT做按位或操作。设置了IPC_CREAT标志后，即使给出的键是一个已有信号量的键，也不会产生错误。而IPC_CREAT | IPC_EXCL则可以创建一个新的，唯一的信号量，如果信号量已存在，返回一个错误。

semget函数成功返回一个相应信号标识符（非零），失败返回-1.

2、semop函数

它的作用是改变信号量的值，原型为：

[cpp] view plain copy

print?

  1. int semop(int sem_id, struct sembuf *sem_opa, size_t num_sem_ops);

sem_id是由semget返回的信号量标识符，sembuf结构的定义如下：

[cpp] view plain copy

print?

  1. struct sembuf{
  2. short sem_num;//除非使用一组信号量，否则它为0
  3. short sem_op;//信号量在一次操作中需要改变的数据，通常是两个数，一个是-1，即P（等待）操作，
  4. //一个是+1，即V（发送信号）操作。
  5. short sem_flg;//通常为SEM_UNDO,使操作系统跟踪信号，
  6. //并在进程没有释放该信号量而终止时，操作系统释放信号量
  7. };

3、semctl函数

该函数用来直接控制信号量信息，它的原型为：

[cpp] view plain copy

print?

  1. int semctl(int sem_id, int sem_num, int command, ...);

如果有第四个参数，它通常是一个union semum结构，定义如下：

[cpp] view plain copy

print?

  1. union semun{
  2. int val;
  3. struct semid_ds *buf;
  4. unsigned short *arry;
  5. };

前两个参数与前面一个函数中的一样，command通常是下面两个值中的其中一个

SETVAL：用来把信号量初始化为一个已知的值。p 这个值通过union semun中的val成员设置，其作用是在信号量第一次使用前对它进行设置。

IPC_RMID：用于删除一个已经无需继续使用的信号量标识符。

四、进程使用信号量通信

下面使用一个例子来说明进程间如何使用信号量来进行通信，这个例子是两个相同的程序同时向屏幕输出数据，我们可以看到如何使用信号量来使两个进程协调工作，使同一时间只有一个进程可以向屏幕输出数据。注意，如果程序是第一次被调用（为了区分，第一次调用程序时带一个要输出到屏幕中的字符作为一个参数），则需要调用set_semvalue函数初始化信号并将message字符设置为传递给程序的参数的第一个字符，同时第一个启动的进程还负责信号量的删除工作。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。

在main函数中调用semget来创建一个信号量，该函数将返回一个信号量标识符，保存于全局变量sem_id中，然后以后的函数就使用这个标识符来访问信号量。

源文件为seml.c，代码如下：

[cpp] view plain copy

print?

  1. #include <unistd.h>
  2. #include <sys/types.h>
  3. #include <sys/stat.h>
  4. #include <fcntl.h>
  5. #include <stdlib.h>
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include <sys/sem.h>
  9. union semun
  10. {
  11. int val;
  12. struct semid_ds *buf;
  13. unsigned short *arry;
  14. };
  15. static int sem_id = 0;
  16. static int set_semvalue();
  17. static void del_semvalue();
  18. static int semaphore_p();
  19. static int semaphore_v();
  20. int main(int argc, char *argv[])
  21. {
  22. char message = ‘X‘;
  23. int i = 0;
  24. //创建信号量
  25. sem_id = semget((key_t)1234, 1, 0666 | IPC_CREAT);
  26. if(argc > 1)
  27. {
  28. //程序第一次被调用，初始化信号量
  29. if(!set_semvalue())
  30. {
  31. fprintf(stderr, "Failed to initialize semaphore\n");
  32. exit(EXIT_FAILURE);
  33. }
  34. //设置要输出到屏幕中的信息，即其参数的第一个字符
  35. message = argv[1][0];
  36. sleep(2);
  37. }
  38. for(i = 0; i < 10; ++i)
  39. {
  40. //进入临界区
  41. if(!semaphore_p())
  42. exit(EXIT_FAILURE);
  43. //向屏幕中输出数据
  44. printf("%c", message);
  45. //清理缓冲区，然后休眠随机时间
  46. fflush(stdout);
  47. sleep(rand() % 3);
  48. //离开临界区前再一次向屏幕输出数据
  49. printf("%c", message);
  50. fflush(stdout);
  51. //离开临界区，休眠随机时间后继续循环
  52. if(!semaphore_v())
  53. exit(EXIT_FAILURE);
  54. sleep(rand() % 2);
  55. }
  56. sleep(10);
  57. printf("\n%d - finished\n", getpid());
  58. if(argc > 1)
  59. {
  60. //如果程序是第一次被调用，则在退出前删除信号量
  61. sleep(3);
  62. del_semvalue();
  63. }
  64. exit(EXIT_SUCCESS);
  65. }
  66. static int set_semvalue()
  67. {
  68. //用于初始化信号量，在使用信号量前必须这样做
  69. union semun sem_union;
  70. sem_union.val = 1;
  71. if(semctl(sem_id, 0, SETVAL, sem_union) == -1)
  72. return 0;
  73. return 1;
  74. }
  75. static void del_semvalue()
  76. {
  77. //删除信号量
  78. union semun sem_union;
  79. if(semctl(sem_id, 0, IPC_RMID, sem_union) == -1)
  80. fprintf(stderr, "Failed to delete semaphore\n");
  81. }
  82. static int semaphore_p()
  83. {
  84. //对信号量做减1操作，即等待P（sv）
  85. struct sembuf sem_b;
  86. sem_b.sem_num = 0;
  87. sem_b.sem_op = -1;//P()
  88. sem_b.sem_flg = SEM_UNDO;
  89. if(semop(sem_id, &sem_b, 1) == -1)
  90. {
  91. fprintf(stderr, "semaphore_p failed\n");
  92. return 0;
  93. }
  94. return 1;
  95. }
  96. static int semaphore_v()
  97. {
  98. //这是一个释放操作，它使信号量变为可用，即发送信号V（sv）
  99. struct sembuf sem_b;
  100. sem_b.sem_num = 0;
  101. sem_b.sem_op = 1;//V()
  102. sem_b.sem_flg = SEM_UNDO;
  103. if(semop(sem_id, &sem_b, 1) == -1)
  104. {
  105. fprintf(stderr, "semaphore_v failed\n");
  106. return 0;
  107. }
  108. return 1;
  109. }

运行结果如下：

注：这个程序的临界区为main函数for循环不的semaphore_p和semaphore_v函数中间的代码。

例子分析 ：同时运行一个程序的两个实例，注意第一次运行时，要加上一个字符作为参数，例如本例中的字符‘O’，它用于区分是否为第一次调用，同时这个字符输出到屏幕中。因为每个程序都在其进入临界区后和离开临界区前打印一个字符，所以每个字符都应该成对出现，正如你看到的上图的输出那样。在main函数中循环中我们可以看到，每次进程要访问stdout（标准输出），即要输出字符时，每次都要检查信号量是否可用（即stdout有没有正在被其他进程使用）。所以，当一个进程A在调用函数semaphore_p进入了临界区，输出字符后，调用sleep时，另一个进程B可能想访问stdout，但是信号量的P请求操作失败，只能挂起自己的执行，当进程A调用函数semaphore_v离开了临界区，进程B马上被恢复执行。然后进程A和进程B就这样一直循环了10次。

五、对比例子——进程间的资源竞争

看了上面的例子，你可能还不是很明白，不过没关系，下面我就以另一个例子来说明一下，它实现的功能与前面的例子一样，运行方式也一样，都是两个相同的进程，同时向stdout中输出字符，只是没有使用信号量，两个进程在互相竞争stdout。它的代码非常简单，文件名为normalprint.c，代码如下：

[cpp] view plain copy

print?

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. int main(int argc, char *argv[])
  4. {
  5. char message = ‘X‘;
  6. int i = 0;
  7. if(argc > 1)
  8. message = argv[1][0];
  9. for(i = 0; i < 10; ++i)
  10. {
  11. printf("%c", message);
  12. fflush(stdout);
  13. sleep(rand() % 3);
  14. printf("%c", message);
  15. fflush(stdout);
  16. sleep(rand() % 2);
  17. }
  18. sleep(10);
  19. printf("\n%d - finished\n", getpid());
  20. exit(EXIT_SUCCESS);
  21. }

运行结果如下：

例子分析：

从上面的输出结果，我们可以看到字符‘X’和‘O’并不像前面的例子那样，总是成对出现，因为当第一个进程A输出了字符后，调用sleep休眠时，另一个进程B立即输出并休眠，而进程A醒来时，再继续执行输出，同样的进程B也是如此。所以输出的字符就是不成对的出现。这两个进程在竞争stdout这一共同的资源。通过两个例子的对比，我想信号量的意义和使用应该比较清楚了。

六、信号量的总结

信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操作。我们通常通过信号来解决多个进程对同一资源的访问竞争的问题，使在任一时刻只能有一个执行线程访问代码的临界区域，也可以说它是协调进程间的对同一资源的访问权，也就是用于同步进程的。

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

时间： 2024-11-09 01:47:43

Linux进程间通信——使用共享内存(转)的相关文章

Linux进程间通信—使用共享内存

Linux进程间通信-使用共享内存 转自: https://blog.csdn.net/ljianhui/article/details/10253345 下面将讲解进程间通信的另一种方式,使用共享内存. 一.什么是共享内存 顾名思义,共享内存就是允许两个不相关的进程访问同一个逻辑内存.共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式.不同进程之间共享的内存通常安排为同一段物理内存.进程可以将同一段共享内存连接到它们自己的地址空间中,所有进程都可以访问共享内存中的地址,就好像

Linux进程间通信——使用共享内存

下面将讲解进程间通信的另一种方式,使用共享内存. 一.什么是共享内存 顾名思义,共享内存就是允许两个不相关的进程访问同一个逻辑内存.共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式.不同进程之间共享的内存通常安排为同一段物理内存.进程可以将同一段共享内存连接到它们自己的地址空间中,所有进程都可以访问共享内存中的地址,就好像它们是由用C语言函数malloc分配的内存一样.而如果某个进程向共享内存写入数据,所做的改动将立即影响到可以访问同一段共享内存的任何其他进程. 特别提醒:共

Linux进程间通信--mmap共享内存（一）

共享内存可以说是最有用的进程间通信方式,也是最快的IPC形式.两个不同进程A.B共享内存的意思是,同一块物理内存被映射到进程A.B各自的进程地址空间.进程A可以即时看到进程B对共享内存中数据的更新,反之亦然.由于多个进程共享同一块内存区域,必然需要某种同步机制,互斥锁和信号量都可以. 采用共享内存通信的一个显而易见的好处是效率高,因为进程可以直接读写内存,而不需要任何数据的拷贝.对于像管道和消息队列等通信方式,则需要在内核和用户空间进行四次的数据拷贝,而共享内存则只拷贝两次数据[1]:一次从输入

Linux进程间通信--shmget()共享内存（二）

共享内存区域是被多个进程共享的一部分物理内存.如果多个进程都把该内存区域映射到自己的虚拟地址空间,则这些进程就都可以直接访问该共享内存区域,从而可以通过该区域进行通信.共享内存是进程间共享数据的一种最快的方法,一个进程向共享内存区域写入了数据,共享这个内存区域的所有进程就可以立刻看到其中的内容.这块共享虚拟内存的页面,出现在每一个共享该页面的进程的页表中.但是它不需要在所有进程的虚拟内存中都有相同的虚拟地址. 图 共享内存映射图 象所有的 System V IPC对象一样,对于共享内存对象的获取

Linux进程间通信--mmap()共享内存（二）

内核怎样保证各个进程寻址到同一个共享内存区域的内存页面 1.page cache及swap cache中页面的区分:一个被访问文件的物理页面都驻留在page cache或swap cache中,一个页面的所有信息由struct page来描述.struct page中有一个域为指针mapping ,它指向一个struct address_space类型结构.page cache或swap cache中的所有页面就是根据address_space结构以及一个偏移量来区分的. 2.文件与addres

Linux进程间通信--shmget()共享内存（一）

大多数共享内存的具体实现,都是把由不同进程之间共享的内存映射为同一段物理内存. 多个进程都把该物理内存区域映射到自己的虚拟地址空间,这些进程就都可以直接访问该共享内存区域,从而可以通过该区域进行通信. 共享内存允许两个不相关的进程访问同一段物理内存, 由于数据不需要在不同的进程间复制,所以它是在两个正在运行的进程之间传递数据的一种非常有效的方式,一个进程向共享内存区域写入数据,共享该区域的所有进程就可以立刻看到其中的数据内容. 注意: 1.如上图所示,共享虚拟内存的页面,出现在每一个共享该页面的

linux进程间通信之共享内存学习记录

进程 狭义定义:进程是正在运行的程序的实例(an instance of a computer program that is being executed). 广义定义:进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动.它是操作系统动态执行的基本单元,在传统的操作系统中,进程既是基本的分配单元,也是基本的执行单元. 进程的概念主要有两点:第一,进程是一个实体.每一个进程都有它自己的地址空间,一般情况下,包括文本区域(text region).数据区域(data region)和堆

Linux进程间通信之共享内存

一,共享内存  内核管理一片物理内存,允许不同的进程同时映射,多个进程可以映射同一块内存,被多个进程同时映射的物理内存,即共享内存.  映射物理内存叫挂接,用完以后解除映射叫脱接. 1,共享内存的特点: 优点:是最快的IPC. 缺点:要编程者自己实现对共享内存互斥访问.如何实现? 2,编程模型:具体函数的用法可以用man手册查看(强力推荐) 进程A: writeshm.c     1) 获得key, ftok()     2) 使用key来创建一个共享内存 shmget()      3) 映射

Linux进程IPC浅析[进程间通信SystemV共享内存]

Linux进程IPC浅析[进程间通信SystemV共享内存] 共享内存概念,概述 共享内存的相关函数 共享内存概念,概述: 共享内存区域是被多个进程共享的一部分物理内存 多个进程都可把该共享内存映射到自己的虚拟内存空间,所有用户空间的进程若要操作共享内存,都要将其映射到自己的虚拟内存空间中,通过映射的虚拟内存空间地址去操作共享内存,从而达到进程间的数据通信 共享内存是进程间共享数据的一种最快的方法,一个进程向共享内存区域写入了数据,共享这个内存区域的所有进程就可以立刻看到其中的内容 本身不提供同