Linux 进程互斥量

分类： Linux编程2010-05-14 23:27 590人阅读 评论(0) 收藏 举报

网上找了下Linux进程间互斥的实现，两种方法，semaphore 和 文件锁。刚开始也尝试用semaphore来实现，但发现sem_wait和singal无法实现Windows下CirtSec，而采用了后者文件锁；

 

但对于读写锁来说实用文件锁实现，存在一定的不足，它分开了读写锁，而没有分开解读写锁，利用UnLock来统一解读写锁，对于这进程间读写锁的实现，还需要再进一步了解才可！

 

基于文件锁而实现的进程间互斥

 

[c-sharp] view plaincopy

1. /*  
2.  * File:   MProcessCritSec.h 
3.  * Author: root 
4.  * 
5.  * Created on 2010年5月13日, 上午4:37 
6.  */  
7.  
8. #ifndef _MPROCESSCRITSEC_H  
9. #define _MPROCESSCRITSEC_H  
10.  
11. #include <fcntl.h>  
12. #include <string>  
13.   
14. using namespace std;  
15.   
16. class MProcessCritSec  
17. {  
18. public:  
19.     MProcessCritSec(char *pFileName);  
20.     virtual ~MProcessCritSec();  
21.   
22. public:  
23.     /* 
24.      * 锁 
25.      */  
26.     bool Lock();  
27.   
28.     /* 
29.      * 解锁 
30.      */  
31.     bool UnLock();  
32.   
33.     /* 
34.      * 非阻塞锁 
35.      */  
36.     bool TryLock(int nWaitTime = 60);  
37.   
38.     /* 
39.      * 判断锁的状态 
40.      */  
41.     bool IsLock();  
42.   
43. private:  
44.     //  
45.     flock   m_lock;  
46.     //  
47.     int     m_nLockValue;  
48.     //  
49.     bool    m_bLocked;  
50.     //  
51.     string   m_strFilePath;  
52. };  
53.  
54. #endif  /* _MPROCESSCRITSEC_H */  
55.   
56.   
57.   
58. /*  
59.  * File:   MProcessCritSec.cpp 
60.  * Author: root 
61.  *  
62.  * Created on 2010年5月13日, 上午4:37 
63.  */  
64.  
65. #include "MProcessCritSec.h"  
66. #include <errno.h>  
67.   
68. using namespace std;  
69.   
70. MProcessCritSec::MProcessCritSec(char *pFileName)  
71. :m_bLocked(false)  
72. {  
73.     m_bLocked = false;  
74.     m_strFilePath.append("/tmp/");  
75.     m_strFilePath.append(pFileName);  
76.   
77.     m_nLockValue = open(m_strFilePath.c_str(), O_WRONLY|O_CREAT, 0777);  
78. }  
79.   
80. MProcessCritSec::~MProcessCritSec()  
81. {  
82.     close(m_nLockValue);  
83.   
84.     remove(m_strFilePath.c_str());  
85. }  
86.   
87. /* 
88.  * 函数作用：锁 
89.  * 函数参数： 
90.  * 函数返回： 
91.  *  bool 
92.  */  
93. bool MProcessCritSec::Lock()  
94. {  
95.     m_lock.l_type = F_WRLCK;  
96.     m_lock.l_whence = SEEK_SET;  
97.     m_lock.l_start = 0;  
98.     m_lock.l_len = 0;  
99.   
100.     if ( fcntl(m_nLockValue, F_SETLKW, &m_lock) != 0 )  
101.         return false;  
102.   
103.     m_bLocked = true;  
104.       
105.     return true;  
106. }  
107.   
108. /* 
109.  * 函数作用：解锁 
110.  * 函数参数： 
111.  * 函数返回： 
112.  *  bool 
113.  */  
114. bool MProcessCritSec::UnLock()  
115. {  
116.     m_lock.l_type = F_UNLCK;  
117.     m_lock.l_whence = SEEK_SET;  
118.     m_lock.l_start = 0;  
119.     m_lock.l_len = 0;  
120.   
121.   
122.     if ( fcntl(m_nLockValue, F_SETLKW, &m_lock) != 0 )  
123.         return false;  
124.   
125.     m_bLocked = false;  
126.       
127.     return true;  
128. }  
129.   
130. /* 
131.  * 函数作用：尝试加锁 
132.  * 函数参数： 
133.  *  nWaitTime : 尝试等待时间 
134.  * 函数返回： 
135.  *  bool 
136.  */  
137. bool MProcessCritSec::TryLock(int nWaitTime)  
138. {  
139.   
140.     return false;  
141. }  
142.   
143. /* 
144.  * 函数作用：判断锁的状态 
145.  * 函数参数： 
146.  * 函数返回： 
147.  *  bool : 锁状态 
148.  */  
149. bool MProcessCritSec::IsLock()  
150. {  
151.     return m_bLocked;  
152. }