Linux文件锁的使用

        文件是一种共享资源,多个进程对同一文件进行操作的时候,必然涉及到竞争状态，因此引入了文件锁实现对共享资源的访问进行保护的机制，通过对文件上锁， 来避免访问共享资源产生竞争
状态。

一、文件锁的分类

        1.建议性锁

        建议性锁本质上是一种协议，程序访问文件之前，先对文件上锁， 上锁成功之后再访问文件，这是建议性锁的一种用法；但是如果你的程序不管三七二十一，在没有对文件上锁的情况下直接访问文件，也是可以访问的，并非无法访问文件。

        2.强制性锁

        如果进程对文件上了强制性锁，其它的进程在没有获取到文件锁的情况下是无法对文件进行访问的。

Linux 系统中，可以调用 flock()、 fcntl()函数对文件上锁

二、flock()函数进行上锁

      函数原型：flock()函数只能产生建议性锁

#include <sys/file.h>
int flock(int fd, int operation);

fd： 参数 fd 为文件描述符，指定需要加锁的文件。
operation： 参数 operation 指定了操作方式，可以设置为以下值的其中一个：
    LOCK_SH： 在 fd 引用的文件上放置一把共享锁。 所谓共享，指的便是多个进程可以拥有对同一个文件的共享锁，该共享锁可被多个进程同时拥有。
    LOCK_EX： 在 fd 引用的文件上放置一把排它锁（或叫互斥锁） 。 所谓互斥，指的便是互斥锁只能同时被一个进程所拥有。
    LOCK_UN： 解除文件锁定状态，解锁、释放锁。除了以上三个标志外，还有一个标志：
    LOCK_NB： 表示以非阻塞方式获取锁。默认情况下，调用 flock()无法获取到文件锁时会阻塞、 直到其它进程释放锁为止。可以指定 LOCK_NB 标志， 如果无法获取到锁应立刻返回（错误返回，并将 errno 设置为 EWOULDBLOCK） ，通常与 LOCK_SH 或 LOCK_EX
一起使用，通过位或运算符组合在一起。
返回值： 成功将返回 0；失败返回-1、并会设置 errno，

使用实例：

        代码1

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/file.h>
#include <signal.h>

/*建议性锁*/

static int fd;  //文件描述符

/* 信号处理函数 */
static void sigint_handler(int sig)
{
    if (SIGINT != sig)
    return;
    /* 解锁 */
    flock(fd, LOCK_UN);
    close(fd);
    printf("进程 1: 文件已解锁!\n");
}

int main(int argc, char *argv[])
{

    if(argc != 2) {
        fprintf(stderr, "Usage: error!\n");
        exit(1);
    }

    fd = open(argv[1], O_WRONLY);   /*只写的方式打开*/
    if(fd < 0) {
        perror("open()");
        exit(1);
    }

    if(flock(fd, LOCK_EX | LOCK_NB) == -1) {    //以非阻塞的方式加锁
        perror("pid 1 lock failed");
        exit(1);
    }

    printf("pid 1 lock successed!\n");

    signal(SIGINT, sigint_handler);

    for(;;)
        sleep(1);

    return 0;

}

①首先利用open函数获取文件描述符fd
②对文件描述符使用非阻塞的方式加一个互斥锁
③注册SIGINT信号处理函数：信号处理函数实现对文件进行解锁
④死循环进行睡眠

代码2：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/file.h>
#include <string.h>

int main(int argc, char *argv[])
{
    char buf[100] = "Hello World!";
    int fd;
    int len;
    if (2 != argc) {
        fprintf(stderr, "usage: %s <file>\n", argv[0]);
        exit(-1);
    }
    /* 打开文件 */
    fd = open(argv[1], O_RDWR);
    if (-1 == fd) {
        perror("open error");
        exit(-1);
    }
    /* 以非阻塞方式对文件加锁(排它锁) */
    if (-1 == flock(fd, LOCK_EX | LOCK_NB))
        perror("进程 2: 文件加锁失败");
    else
        printf("进程 2: 文件加锁成功!\n");
    /* 写文件 */
    len = strlen(buf);
    if (0 > write(fd, buf, len)) {
        perror("write error");
        exit(-1);
    }
    printf("进程 2: 写入到文件的字符串<%s>\n", buf);
    /* 将文件读写位置移动到文件头 */
    if (0 > lseek(fd, 0x0, SEEK_SET)) {
        perror("lseek error");
        exit(-1);
    }
    /* 读文件 */
    memset(buf, 0x0, sizeof(buf)); //清理 buf
    if (0 > read(fd, buf, len)) {
        perror("read error");
        exit(-1);
    }
    printf("进程 2: 从文件读取的字符串<%s>\n", buf);
    /* 解锁、退出 */
    flock(fd, LOCK_UN);
    close(fd);
    exit(0);
}

①首先利用open函数获取文件描述符fd
②对文件描述符使用非阻塞的方式加一个互斥锁
③不管加锁成功还是失败都将buf总的内容写入该文件
④最后从文件中读取写入的内容,并进行打印

运行效果：

运行代码1

运行代码2

从打印信息可以看出,代码2对文件加锁失败了,是因为锁已经被代码1持有,尽管加锁失败,但是代码2对文件的读写仍然是成功的，这就是建议性锁

对代码1发送SIGINT信号,会触发信号处理函数对文件进行解锁,再次运行代码2可以成功对文件进行加锁。 

关于 flock()规则

①同一进程对文件多次加锁不会导致死锁。
②文件关闭的时候，会自动解锁。
③一个进程不可以对另一个进程持有的文件锁进行解锁。
④由 fork()创建的子进程不会继承父进程所创建的锁

三、fcntl()函数进行上锁

        fcntl函数是一个多功能文件描述符管理工具箱，通过配合不同的 cmd 操作命令来实现不同的功能。

#include <unistd.h>
#include <fcntl.h>


int fcntl(int fd, int cmd, ... /* struct flock *flockptr */ );

fd:要加锁的文件描述符

cmd: F_SETLK、 F_SETLKW、 F_GETLK
第三个参数 flockptr 是一个 struct flock 结构体指针 

struct flock
  {
    short int l_type;	/* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK.	*/
    short int l_whence;	/* Where `l_start' is relative to (like `lseek').  */
#ifndef __USE_FILE_OFFSET64
    __off_t l_start;	/* Offset where the lock begins.  */
    __off_t l_len;	/* Size of the locked area; zero means until EOF.  */
#else
    __off64_t l_start;	/* Offset where the lock begins.  */
    __off64_t l_len;	/* Size of the locked area; zero means until EOF.  */
#endif
    __pid_t l_pid;	/* Process holding the lock.  */
  };

l_type： 所希望的锁类型，可以设置为 F_RDLCK、F_WRLCK 和 F_UNLCK 三种类型之一， F_RDLCK
表示共享读锁， F_WRLCK 表示独占写锁， F_UNLCK 表示解锁一个区域。
    l_whence 和 l_start： 这两个变量用于指定要加锁或解锁区域的起始字节偏移量。
    l_len： 需要加锁或解锁区域的字节长度。
    l_pid： 一个 pid，指向一个进程，表示该进程持有的锁能阻塞当前进程，当 cmd=F_GETLK 时有效。
以上便是对 struct flock 结构体各成员变量的简单介绍，对于加锁和解锁区域的说明，还需要注意以下
几项规则：
    锁区域可以在当前文件末尾处开始或者越过末尾处开始，但是不能在文件起始位置之前开始。
    若参数 l_len 设置为 0，表示将锁区域扩大到最大范围，也就是说从锁区域的起始位置开始， 到文
件的最大偏移量处（也就是文件末尾）都处于锁区域范围内。而且是动态的， 这意味着不管向该文
件追加写了多少数据，它们都处于锁区域范围，起始位置可以是文件的任意位置。
    如果我们需要对整个文件加锁，可以将 l_whence 和 l_start 设置为指向文件的起始位置， 并且指定
参数 l_len 等于 0。

测试代码： 

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>


int main(int argc, char *argv[])
{
    struct flock wr_lock = {0};
    struct flock rd_lock = {0};
    int fd = -1;
    /* 校验传参 */
    if (2 != argc) {
        fprintf(stderr, "usage: %s <file>\n", argv[0]);
        exit(-1);
    }
    /* 打开文件 */
    fd = open(argv[1], O_RDWR);
    if (-1 == fd) {
        perror("open error");
        exit(-1);
    }
    /* 将文件大小截断为 1024 字节 */
    ftruncate(fd, 1024);
    /* 对 100~200 字节区间加写锁 */
    wr_lock.l_type = F_WRLCK;
    wr_lock.l_whence = SEEK_SET;
    wr_lock.l_start = 100;
    wr_lock.l_len = 100;
    if (-1 == fcntl(fd, F_SETLK, &wr_lock)) {
        perror("加写锁失败");
        exit(-1);
    }
    printf("加写锁成功!\n");
    /* 对 400~500 字节区间加读锁 */
    rd_lock.l_type = F_RDLCK;
    rd_lock.l_whence = SEEK_SET;
    rd_lock.l_start = 400;
    rd_lock.l_len = 100;
    if (-1 == fcntl(fd, F_SETLK, &rd_lock)) {
        perror("加读锁失败");
        exit(-1);
    }
    printf("加读锁成功!\n");

    /* 解锁 */
    wr_lock.l_type = F_UNLCK; //写锁解锁
    fcntl(fd, F_SETLK, &wr_lock);
    rd_lock.l_type = F_UNLCK; //读锁解锁
    fcntl(fd, F_SETLK, &rd_lock);
    /* 退出 */
    close(fd);
    exit(0);
}

一个进程可以对同一个文件的不同区域进行加锁，该程序对文件的 100~200 字节区间加了一个写锁，对文件的 400~500 字节区间加了一个读锁。

读锁的共享性测试： 

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>


int main(int argc, char *argv[])
{
    struct flock lock = {0};
    int fd = -1;
    /* 校验传参 */
    if (2 != argc) {
        fprintf(stderr, "usage: %s <file>\n", argv[0]);
        exit(-1);
    }
    /* 打开文件 */
    fd = open(argv[1], O_RDWR);
    if (-1 == fd) {
        perror("open error");
        exit(-1);
    }
    /* 将文件大小截断为 1024 字节 */
    ftruncate(fd, 1024);
    /* 对 400~500 字节区间加读锁 */
    lock.l_type = F_RDLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = 400;
    lock.l_len = 100;
    if (-1 == fcntl(fd, F_SETLK, &lock)) {
        perror("加读锁失败");
        exit(-1);
    }
    printf("加读锁成功!\n");
    for ( ; ; )
    sleep(1);
}

从打印信息可以发现，多个进程对同一文件的相同区域都可以加读锁，说明读锁是共享性的。

写锁的独占性测试：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
    struct flock lock = {0};
    int fd = -1;
    /* 校验传参 */
    if (2 != argc) {
        fprintf(stderr, "usage: %s <file>\n", argv[0]);
        exit(-1);
    }
    /* 打开文件 */
    fd = open(argv[1], O_RDWR);
    if (-1 == fd) {
        perror("open error");
        exit(-1);
    }
    /* 将文件大小截断为 1024 字节 */
    ftruncate(fd, 1024);
    /* 对 400~500 字节区间加写锁 */
    lock.l_type = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = 400;
    lock.l_len = 100;
    if (-1 == fcntl(fd, F_SETLK, &lock)) {
        perror("加写锁失败");
        exit(-1);
    }
    printf("加写锁成功!\n");
    for ( ; ; )
    sleep(1);
}

        由打印信息可知，但第一次启动的进程对文件加写锁之后，后面再启动进程对同一文件的相同区域加写锁发现都会失败，所以由此可知，写锁是独占性的。

关于fcntl函数的规则：
        ①文件关闭的时候，会自动解锁。
        ②一个进程不可以对另一个进程持有的文件锁进行解锁。
        ③由 fork()创建的子进程不会继承父进程所创建的锁

注意：

        当一个文件描述符被复制时（譬如使用 dup()、 dup2()或 fcntl()F_DUPFD 操作） ，这些通过
复制得到的文件描述符和源文件描述符都会引用同一个文件锁， 使用这些文件描述符中的任何一个进行解锁都可以：

例如：

flock(fd, LOCK_EX); //加锁
new_fd = dup(fd);
flock(new_fd, LOCK_UN); //解锁



lock.l_type = F_RDLCK;
fcntl(fd, F_SETLK, &lock);//加锁
new_fd = dup(fd);
lock.l_type = F_UNLCK;
fcntl(new_fd, F_SETLK, &lock);//解锁

对于flock函数上的锁,如果不进行主动解锁的话,只有文件描述符fd和new_fd都关闭才会自动解锁。而fcntl函数上的锁,fd和new_fd任意一个关闭都会自动解锁。