文件锁及其实例

1.  文件锁基本概念

Linux中软件、硬件资源都是文件（一切皆文件），文件在多用户环境中是可共享的。

文件锁是用于解决资源的共享使用的一种机制：当多个用户需要共享一个文件时，Linux通常采用的方法是给文件上锁，来避免共享的资源产生竞争的状态。

文件锁包括建议性锁和强制性锁：

建议性锁：要求每个使用上锁文件的进程都要检查是否有锁存在，并且尊重已有的锁。在一般情况下，内核和系统都不使用建议性锁，它们依靠程序员遵守这个规定。
强制性锁：是由内核执行的锁，当一个文件被上锁进行写入操作的时候，内核将阻止其他任何文件对其进行读写操作。采用强制性锁对性能的影响很大，每次读写操作都必须检查是否有锁存在。

在Linux中，实现文件上锁的函数有lockf()和fcntl()

• lockf()用于对文件施加建议性锁
  
  
• fcntl()不仅可以施加建议性锁，还可以施加强制锁。
  
  
• fcntl()还能对文件的某一记录上锁，也就是记录锁。
  
  
• 记录锁又可分为读取锁和写入锁，其中读取锁又称为共享锁，它能够使多个进程都能在文件的同一部分建立读取锁。
  
  
• 写入锁又称为排斥锁，在任何时刻只能有一个进程在文件的某个部分建立写入锁。
  
  
• 在文件的同一部分不能同时建立读取锁和写入。

2.  fcntl()函数格式
          fcntl是一个非常通用的函数，它可以对已打开的文件进行各种操作，包括管理文件锁、获得和设置文件描述符标志、获得和设置文件状态标志、文件描述符的复制等很多功能，
所需头文件
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
函数原型：int fcntl(int fd,int cmd,...);
int fcntl(int fd,int cmd,long arg);
int fcntl(int fd, int cmd, struct flock *lock)
函数传入值fd：被参数cmd操作的文件描述符

函数原型
int fcntl(int fd,int cmd,long arg);
int fcnt1(int fd, int cmd, struct flock *lock)
函数传入值cmd
F_DUPFD：复制一个现存的描述符
F_GETFD：获得fd的close-on-exec（执行时关闭）文件描述符标志，若标志未设置，则文件经过exec()函数之后仍保持打开状态
F_SETFD：设置close-on-exec 标志，该标志由参数arg 的FD_CLOEXEC位决定
F_GETFL：得到open设置的标志
F_SETFL ：改变open设置的标志
F_GETLK：根据lock参数值，决定是否可以上文件锁
F_SETLK：设置lock参数值的文件锁

关于close_on_exec
close_on_exec 是一个进程所有文件描述符（文件句柄）的位图标志，每个比特位代表一个打开的文件描述符，用于确定在调用系统调用execve()时需要关闭的文件句柄（参见include/fcntl.h）。当一个程序使用fork()函数创建了一个子进程时，通常会在该子进程中调用execve()函数加载执行另一个新程序。此时子进程将完全被新程序替换掉，并在子进程中开始执行新程序。若一个文件描述符在close_on_exec中的对应比特位被设置，那么在执行execve()时该描述符将被关闭，否则该描述符将始终处于打开状态。

函数传入值cmd
F_SETLKW：这是F_SETLK的阻塞版本（命令名中的W表示等待（wait））。在无法加锁时，会进入睡眠状态；如果可以加锁或者捕捉到信号则会返回
lock：是一个指向flock结构的指针，设置记录锁的具体状态
函数返回值
成功时，返回值依赖于第二个参数cmd
-1：出错

cmd取值方式
F_GETLK, F_SETLK或F_SETLKW：      获得／设置记录锁的功能，成功则返回0，若有错误则返回-1，错误原因存于errno。
F_GETLK ：   测试由lock所描述的锁是否能使用。如果存在一把锁，它阻止创建由lock所描述的锁，则将这把现存锁的信息写到lock指向的结构中（l_type-已有锁的类型,l_pid-加锁的进程号）。如果不存在这种情况，则除了将l_type设置为F_UNLCK之外，lock所指向的结构中的其他信息保持不变。

F_SETLK ： 按照第三个参数lock指向的flock结构体所描述的锁的信息设置或者清除一个文件的锁。

F_SETLK： 被用来实现共享(或读)锁(F_RDLCK)或独占(写)锁(F_WRLCK)，同样可以去掉这两种锁(F_UNLCK)。如果共享锁或独占锁不能被设置，fcntl()将立即返回EAGAIN   

3.  fcntl()使用实例

在该下面的实例中，首先给flock结构体的对应字段赋予相应的值。
接着使用两次fcntl()函数，分别用于判断文件是否可以上锁和给相关文件上锁，这里用到的cmd值分别为F_GETLK和F_SETLK（或F_SETLKW）。
用 F_GETLK 命令判断是否可以进行flock 结构所描述的锁操作：
若可以加锁，则flock结构的l_type会被设置为F_UNLCK，其他域不变；
否则，则l_pid被设置为拥有文件锁的进程号，l_type被设置为已有锁的类型，其他域不变。

• 文件记录所功能源代码如下（文件保存为 mylock.c）：

[cpp]  view plain  copy

1. /* 文件保存为 mylock.c */  
2.   
3. int lock_set(int fd,int type)  
4. {  
5.     struct flock old_lock,lock;  
6.     lock.l_whence = SEEK_SET;  
7.     lock.l_start = 0;  
8.     lock.l_len = 0;  
9.     lock.l_type = type;  
10.     lock.l_pid = -1;  
11.           
12.     fcntl(fd,F_GETLK,&lock);  
13.   
14.     if(lock.l_type != F_UNLCK)  
15.     {  
16.           
17.         if (lock.l_type == F_RDLCK)    
18.         {  
19.             printf("Read lock already set by %d\n",lock.l_pid);  
20.         }  
21.         else if (lock.l_type == F_WRLCK)   
22.         {  
23.             printf("Write lock already set by %d\n",lock.l_pid);  
24.         }                         
25.     }  
26.       
27.     lock.l_type = type;  
28.       
29.     if ((fcntl(fd,F_SETLKW,&lock)) < 0)  
30.     {  
31.         printf("Lock failed : type = %d\n",lock.l_type);  
32.         return 1;  
33.     }  
34.       
35.     switch (lock.l_type)  
36.     {  
37.         case F_RDLCK:  
38.         {  
39.             printf("Read lock set by %d\n",getpid());  
40.         }  
41.         break;  
42.         case F_WRLCK:  
43.         {  
44.             printf("write lock set by %d\n",getpid());  
45.         }  
46.         break;  
47.         case F_UNLCK:  
48.         {  
49.             printf("Release lock by %d\n",getpid());  
50.             return 1;  
51.         }  
52.         break;  
53.           
54.         default:  
55.         break;  
56.   
57.     }  
58.     return 0;  
59. }  

• 下面的实例是文件写入锁的测试用例，文件名为，wirte_lock.c 。
  这里首先创建了一个hello 文件，之后对其上写入锁，最后释放写入锁，代码如下所示：

[cpp]  view plain  copy

1. #include<stdio.h>  
2. #include <unistd.h>  
3. #include <sys/file.h>  
4. #include <sys/types.h>  
5. #include <sys/stat.h>  
6. #include <stdlib.h>  
7. #include "mylock.c"  
8. int main(void)  
9. {    
10.     int fd;/* 首先打开文件*/  
11.     fd = open("hello",O_RDWR | O_CREAT, 0644);if(fd < 0)  
12.     {         
13.         printf("Open file error\n");      
14.         exit(1);     
15.     }      
16.     lock_set(fd, F_WRLCK);      /* 给文件上写入锁*/    
17.     getchar();             /*程序暂停，按回车键继续*/      
18.     lock_set(fd, F_UNLCK);  /* 给文件解锁*/     
19.     getchar();     
20.     close(fd);     
21.     exit(0);      
22.     return 0;  
23. }  

运行截图如下：

在PC机上测试：
开启两个终端，并且在两个终端上同时运行该程序，以达到多个进程操作一个文件的效果。
首先在终端1运行，然后在终端2上运行，注意终端二中的第一行输出。

由此可见，写入锁为互斥锁，同一时刻只能有一个写入锁存在。

接下来的程序是文件读取锁的测试用例，原理和上面的程序一样。文件名为read_lock.c。

[cpp]  view plain  copy

1. #include <unistd.h>  
2. #include <sys/file.h>  
3. #include <sys/types.h>  
4. #include <sys/stat.h>  
5. #include <stdio.h>  
6. #include <stdlib.h>  
7. #include "mylock.c"  
8. int main(void)  
9. {  
10.     int fd;fd = open("hello",O_RDWR | O_CREAT, 0644);if(fd < 0)  
11.     {     
12.         printf("Open file error\n");  
13.         exit(1);    
14.     }  
15.     lock_set(fd, F_RDLCK);  /* 给文件上读取锁*/  
16.     getchar();  
17.     lock_set(fd, F_UNLCK);  /* 给文件解锁*/  
18.     getchar();  
19.     close(fd);  
20.     exit(0);      
21.     return 0;  
22. }  

运行结果如下：

同样开启两个终端，并首先启动终端一上的程序，其运行结果如下所示：

观察可知，读锁是共享锁。