进程之间的锁机制。

Question

本帖最后由 lemboyz 于 2011-05-13 14:40 编辑

线程之间有方便的线程锁、读写锁，进程之间可以用fcntl

写了个例子，供大家参考。

2. // filename: proclock.hpp
4. #include <errno.h>
5. #include <iostream>
6. #include <stdexcept>
7. #include <sys/types.h>
8. #include <sys/stat.h>
9. #include <fcntl.h>
10. using namespace std;
12. class CProcLock
13. {
14. private:
15.     int fd_;
17. public:
18.     CProcLock(const string& filename);
19.     ~CProcLock() {
20.         unlock();
21.         close(fd_);
22.     }
24.     void writelock();
25.     void readlock();
26.     void unlock();
27. };

复制代码

2. // filename: proclock.cpp
4. #include "proclock.hpp"
6. CProcLock::CProcLock(const string& filename)
7. {
8.     fd_ = open(filename.c_str(),O_RDWR,O_CREAT);
9.     if(fd_ == -1) {
10.         throw runtime_error(string("CProcLock() error,")+strerror(errno));
11.     }
12. }
14. void CProcLock::writelock()
15. {
16.     struct flock lck;
17.     lck.l_type = F_WRLCK;
18.     lck.l_whence = SEEK_SET;
19.     lck.l_start = 0;
20.     lck.l_len = 0;
21.     if ( fcntl(fd_,F_SETLKW,&lck) == -1) {
22.         throw runtime_error(string("CProcLock::writelock() error,")+strerror(errno));
23.     }
24. }
26. void CProcLock::readlock()
27. {
28.     struct flock lck;
29.     lck.l_type = F_RDLCK;
30.     lck.l_whence = SEEK_SET;
31.     lck.l_start = 0;
32.     lck.l_len = 0;
33.     if ( fcntl(fd_,F_SETLKW,&lck) == -1) {
34.         throw runtime_error(string("CProcLock::readlock() error,")+strerror(errno));
35.     }
36. }
38. void CProcLock::unlock()
39. {
40.     struct flock lck;
41.     lck.l_type = F_UNLCK;
42.     lck.l_whence = SEEK_SET;
43.     lck.l_start = 0;
44.     lck.l_len = 0;
45.     if ( fcntl(fd_,F_SETLK, &lck) == -1) {
46.         throw runtime_error(string("CProcLock::unlock() error,")+strerror(errno));
47.     }
48. }

复制代码

2. // filename: main.cpp
3. // for testing CProcLock
5. #include <iostream>
6. #include "proclock.hpp"
7. using namespace std;
9. int main(int argc,char ** argv)
10. {
11.     if(argc != 4) {
12.         cout << "usage: " << argv[0] << " filename type[read|write] lock_seconds" << endl;
13.         return 0;
14.     }
16.     string file = argv[1];
17.     string type = argv[2];
18.     int sec = atoi(argv[3]);
20.     CProcLock lock(file);
22.     cout << "before lock()" << endl;
23.     if(type == "read")
24.     {
25.         lock.readlock();
26.         cout << "read locking." << endl;
27.     }
28.     else
29.     {
30.         lock.writelock();
31.         cout << "write locking." << endl;
32.     }
34.     sleep(sec);
35.     lock.unlock();
36.     cout << "lock finished." << endl;
38. }

复制代码

Answer 1

文件锁用在进程间同步还是很方便的。

Answer 2

进程之间通常没有共享内存，为什么要这样使用互斥锁？
资源互斥简单的检查x.lock文件是否存在就行了。
异步通知有管道，信号……