利用POSIX互斥鎖和條件變量實現的信號量

利用POSIX互斥鎖、條件變量，和內存映射文件，實現的信號量機制，用於進程間的同步。

1. /* sem.h */
2. struct semaphore
3. {
4. pthread_mutex_t lock;
5. pthread_cond_t nonzero;
6. unsigned count;
7. };
8. typedef struct semaphore semaphore_t;
11. semaphore_t* semaphore_create(char *semaphore_name);
12. semaphore_t* semaphore_open(char *semaphore_name);
13. void semaphore_post(semaphore_t *semap);
14. void semaphore_wait(semaphore_t *semap);
15. void semaphore_close(semaphore_t *semap);
18. /* sem.c */
19. #include <sys/types.h>
20. #include <sys/stat.h>
21. #include <sys/mman.h>
22. #include <fcntl.h>
23. #include <pthread.h>
24. #include "sem.h"
27. semaphore_t* semaphore_create(char *semaphore_name)
28. {
29. int fd = open(semaphore_name, O_RDWR | O_CREAT | O_EXCL, 0666);
30. if (fd < 0) return (NULL);
31. (void) ftruncate(fd, sizeof(semaphore_t));
33. pthread_mutexattr_t psharedm;
34. pthread_condattr_t psharedc;
35. (void) pthread_mutexattr_init(&psharedm);
36. (void) pthread_mutexattr_setpshared(&psharedm, PTHREAD_PROCESS_SHARED);
37. (void) pthread_condattr_init(&psharedc);
38. (void) pthread_condattr_setpshared(&psharedc, PTHREAD_PROCESS_SHARED);
39. semaphore_t* semap = (semaphore_t *) mmap(NULL,
40. sizeof(semaphore_t),
41. PROT_READ | PROT_WRITE,
42. MAP_SHARED,
43. fd,
44. 0);
45. close (fd);
46. (void) pthread_mutex_init(&semap->lock, &psharedm);
47. (void) pthread_cond_init(&semap->nonzero, &psharedc);
49. // 我覺得應該給個大於零的初值
50. semap->count = 0;
51. return (semap);
52. }
55. semaphore_t* semaphore_open(char *semaphore_name)
56. {
57. int fd = open(semaphore_name, O_RDWR, 0666);
58. if (fd < 0) return (NULL);
60. semaphore_t* semap = (semaphore_t *) mmap(NULL,
61. sizeof(semaphore_t),
62. PROT_READ | PROT_WRITE,
63. MAP_SHARED,
64. fd,
65. 0);
66. close (fd);
67. return (semap);
68. }
71. void semaphore_post(semaphore_t *semap)
72. {
73. pthread_mutex_lock(&semap->lock);
74. // 計數為零，說明可能有線程已經阻塞在該條件變量上
75. if (semap->count == 0)
76. {
77. pthread_cond_signal(&semapx->nonzero);
78. }
79. semap->count++;
80. pthread_mutex_unlock(&semap->lock);
81. }
84. void semaphore_wait(semaphore_t *semap)
85. {
86. pthread_mutex_lock(&semap->lock);
87. // 計數為零，說明已無資源，等待
88. while (semap->count == 0)
89. {
90. pthread_cond_wait(&semap->nonzero, &semap->lock);
91. }
92. semap->count--;
93. pthread_mutex_unlock(&semap->lock);
94. }
97. void semaphore_close(semaphore_t *semap)
98. {
99. munmap((void *) semap, sizeof(semaphore_t));
100. }