Unix/linux inter-process file lock

Transfer from http://www.cnblogs.com/hjslovewcl/archive/2011/03/14/2314333.html

There are three different file locks, three of which are "advisory", which means they rely on the
Cooperation, so it is very important for all programs in a project to blockade policy to be consistent when your program requires
You should take extra care when sharing files with third-party software.

Some programs use file lock files such as Filename.lock, and then simply test for the existence of such files. This method is obviously not very good, because when the file-generating process is killed, the lock file still exists, so that the file may be permanently locked. The process number PID of the generated file is stored in the UUCP file, but this is still not insured, because the use of PID is recycled.

Here are three file lock functions:
Flock ();
LOCKF ();
Fcntl ();

Flock () is derived from BSD, but is now available on most Unix systems, in a single master
On-machine flock () is simple and effective, but it cannot work on NFS. There's a little bit confusing in Perl, too.
Flock () function, but it is implemented inside Perl.

Fcntl () is the only POSIX-compliant file lock implementation and is therefore the only portable. It is also the same
Is the most powerful file lock--and the hardest to use. On an NFS file system, the FCNTL () request is passed
To the daemon called RPC.LOCKD, which is then responsible for the LOCKD conversation with the host side, and Flock ()
Different, fcntl () can implement blocking on the record layer.

LOCKF () is just a simplified fcntl () file lock interface.

Regardless of which file lock you use, be sure to remember to update all your files with sync before the lock takes effect
Input/output.

2. Lock (FD);
4. Write_to (Some_function_of (FD));
6. Flush_output_to (FD); / * Rinse the output before going to the lock * /
8. Unlock (FD);
10. Do_something_else; / * Maybe another process will update it * /
12. Lock (FD);
14. Seek (fd, somewhere); / * Because the original file pointer is not secure * /
16. Do_something_with (FD); ...
18. Some useful fcntl () blocking methods (to omit error handling for brevity):
20. #include <fcntl.h>;
22. #include <unistd.h>;
26. Read_lock (int fd)/ * A shared file lock on the entire file * /
28. {
30. Fcntl (FD, F_SETLKW, File_lock (F_rdlck, Seek_set));
32. }
36. Write_lock (int fd)/ * An exclusive file lock on the entire file * /
38. {
40. Fcntl (FD, F_SETLKW, File_lock (F_wrlck, Seek_set));
42. }
46. Append_lock (int fd)/ * A lock that closes the end of the file,
48. Other processes can access existing content */
50. {
52. Fcntl (FD, F_SETLKW, File_lock (F_wrlck, seek_end));
54. }
56. The File_lock function used earlier is as follows:
58. struct flock* file_lock (shorttype, short whence)
60. {
62. static struct flock ret;
64. Ret.l_type = type;
66. Ret.l_start = 0;
68. Ret.l_whence = whence;
70. Ret.l_len = 0;
72. Ret.l_pid = Getpid ();
74. return &ret;
76. }

2. Lock.c
4. #include <stdio.h>
6. #include <unistd.h>
8. #include <fcntl.h>
10. #include <string.h>
12. struct flock* file_lock (shorttype, short whence)
14. {
16. static struct flock ret;
18. Ret.l_type = type;
20. Ret.l_start = 0;
22. Ret.l_whence = whence;
24. Ret.l_len = 0;
26. Ret.l_pid = Getpid ();
28. return &ret;
30. }
32. int main ()
34. {
36. int fd = open ("1.txt", o_wronly|  O_append);
38. For (int i=0; i<1000; ++i) {
40. Fcntl (FD, F_SETLKW, File_lock (F_wrlck, Seek_set));
42. char buf[1024] = {0};
44. sprintf (buf, "Hello World%d/n", I);
46. int len = strlen (BUF);
48. Write (FD, buf, Len);
50. Fcntl (FD, F_SETLKW, File_lock (F_unlck, Seek_set));
52. Sleep (1);
54. }
56. Close (FD);
58. }
60. Lock2.c ... Compared with LOCK.C, only modified the next BUF content
62. #include <stdio.h>
64. #include <unistd.h>
66. #include <fcntl.h>
68. #include <string.h>
70. struct flock* file_lock (shorttype, short whence)
72. {
74. static struct flock ret;
76. Ret.l_type = type;
78. Ret.l_start = 0;
80. Ret.l_whence = whence;
82. Ret.l_len = 0;
84. Ret.l_pid = Getpid ();
86. return &ret;
88. }
90. int main ()
92. {
94. int fd = open ("1.txt", o_wronly|  O_append);
96. For (int i=0; i<1000; ++i) {
98. Fcntl (FD, F_SETLKW, File_lock (F_wrlck, Seek_set));
100. char buf[1024] = {0};
102. sprintf (buf, "China%d/n", i);
104. int len = strlen (BUF);
106. Write (FD, buf, Len);
108. Fcntl (FD, F_SETLKW, File_lock (F_unlck, Seek_set));
110. Sleep (1);
112. }
114. Close (FD);
116. }
120. g++ Lock.c-o 1
122. g++ Lock2.c-o 2
124. Execute two programs to see the mutex effect.

Unix/linux inter-process file lock