文件锁

    1．fcntl()函数说明

    前面讲述的5个基本函数实现了文件的打开、读/写等基本操作，本节将讨论在文件已经共享的情况下如何操作，也就是当多个用户共同使用、操作一个文件的情况。这时，Linux通常采用的方法是给文件上锁，来避免共享的资源产生竞争的状态。

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

    在Linux中，实现文件上锁的函数有lockf()和fcntl()，其中lockf()用于对文件施加建议性锁，而fcntl()不仅可以施加建议性锁，还可以施加强制性锁。同时，fcntl()还能对文件的某一记录上锁，也就是记录锁。

    记录锁又可分为读取锁和写入锁，其中读取锁又称为共享锁，它能够使多个进程都能在文件的同一部分建立读取锁。而写入锁又称为排斥锁，在任何时刻只能有一个进程在文件的某个部分建立写入锁。当然，在文件的同一部分不能同时建立读取锁和写入锁。

    fcntl()函数具有很丰富的功能，它可以对已打开的文件描述符进行各种操作，不仅包括管理文件锁，还包括获得设置文件描述符和文件描述符标志、文件描述符的复制等很多功能。本节主要介绍fcntl()函数建立记录锁的方法，关于它的其他操作，感兴趣的读者可以参看fcntl手册。

    2．fcntl()函数格式

    用于建立记录锁的fcntl()函数语法要点如表2.6所示。

表2.6 fcntl()函数语法要点

    这里，lock的结构如下所示：

    struct flock
    {
        short l_type;
        off_t l_start;
        short l_whence;
        off_t l_len;
        pid_t l_pid;
    }

    lock结构中每个变量的取值含义如表2.7所示。

表2.7 lock结构变量取值

    为加锁整个文件，通常的方法是将l_start设置为0，l_whence设置为SEEK_SET，l_len设置为0。

    3．fcntl()使用实例

    下面首先给出了使用fcntl()函数的文件记录锁功能的代码实现。在该代码中，首先给flock结构体的对应位赋予相应的值。

    接着调用两次fcntl()函数。用F_GETLK命令判断是否可以进行flock结构所描述的锁操作：若可以进行，则flock结构的l_type会被设置为F_UNLCK，其他域不变；若不可进行，则l_pid被设置为拥有文件锁的进程号，其他域不变。

    用F_SETLK和F_SETLKW命令设置flock结构所描述的锁操作，后者是前者的阻塞版。

    当第一次调用fcntl()时，使用F_GETLK命令获得当前文件被上锁的情况，由此可以判断能不能进行上锁操作；当第二次调用fcntl()时，使用F_SETLKW命令对指定文件进行上锁/解锁操作。因为F_SETLKW命令是阻塞式操作，所以，当不能把上锁/解锁操作进行下去时，运行会被阻塞，直到能够进行操作为止。

    文件记录锁的功能代码具体如下所示：

    /* lock_set.c */
    int lock_set(int fd, int type)
    {
        struct flock old_lock, lock;
        lock.l_whence = SEEK_SET;
        lock.l_start = 0;
        lock.l_len = 0;
        lock.l_type = type;
        lock.l_pid = -1;

        /* 判断文件是否可以上锁 */
        fcntl(fd, F_GETLK, &lock);
        if (lock.l_type != F_UNLCK)
        {
            /* 判断文件不能上锁的原因 */
            if (lock.l_type == F_RDLCK) /* 该文件已有读取锁 */
            {
                printf("Read lock already set by %d\n", lock.l_pid);
            }
            else if (lock.l_type == F_WRLCK) /* 该文件已有写入锁 */
            {
                printf("Write lock already set by %d\n", lock.l_pid);
            }
        }

        /* l_type 可能已被F_GETLK修改过 */
        lock.l_type = type;
        /* 根据不同的type值进行阻塞式上锁或解锁 */
        if ((fcntl(fd, F_SETLKW, &lock)) < 0)
        {
            printf("Lock failed:type = %d\n", lock.l_type);
            return 1;
        }

        switch(lock.l_type)
        {
            case F_RDLCK:
            {
                printf("Read lock set by %d\n", getpid());
            }
            break;
            case F_WRLCK:
            {
                printf("Write lock set by %d\n", getpid());
            }
            break;
            case F_UNLCK:
            {
                printf("Release lock by %d\n", getpid());
                return 1;
            }
            break;
            default:
            break;
        }/* end of switch */
        return 0;
    }

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

    /* write_lock.c */
    #include <unistd.h>
    #include <sys/file.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include "lock_set.c"

    int main(void)
    {
        int fd;

        /* 首先打开文件 */
        fd = open("hello",O_RDWR | O_CREAT, 0644);
        if(fd < 0)
        {
            printf("Open file error\n");
            exit(1);
        }

        /* 给文件上写入锁 */
        lock_set(fd, F_WRLCK);
        getchar();
        /* 给文件解锁 */
        lock_set(fd, F_UNLCK);
        getchar();
        close(fd);
        exit(0);
    }

    为了能够使用多个终端，更好地显示写入锁的作用，本实例主要在PC上测试，读者可将其交叉编译，下载到目标板上运行。下面是在PC上的运行结果。为了使程序有较大的灵活性，笔者采用文件上锁后由用户输入任意键使程序继续运行。建议读者开启两个终端，并且在两个终端上同时运行该程序，以达到多个进程操作一个文件的效果。在这里，笔者首先运行终端一，请读者注意终端二中的第一句。

    终端一：

    $ ./write_lock
    write lock set by 4994
    release lock by 4994

    终端二：

    $ ./write_lock
    write lock already set by 4994
    write lock set by 4997
    release lock by 4997

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

    接下来的程序是文件读取锁的测试用例，原理与上面的程序一样。

    /* fcntl_read.c */
    #include <unistd.h>
    #include <sys/file.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include "lock_set.c"

    int main(void)
    {
        int fd;
        fd = open("hello",O_RDWR | O_CREAT, 0644);
        if(fd < 0)
        {
            printf("Open file error\n");
            exit(1);
        }

        /* 给文件上读取锁 */
        lock_set(fd, F_RDLCK);
        getchar();
        /* 给文件解锁 */
        lock_set(fd, F_UNLCK);
        getchar();
        close(fd);
        exit(0);
    }

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

    终端一：

    $ ./read_lock
    read lock set by 5009
    release lock by 5009

    终端二：

    $ ./read_lock
    read lock set by 5010
    release lock by 5010

    读者可以将此结果与写入锁的运行结果相比较，可以看出，读取锁为共享锁，当进程5009已设置读取锁后，进程5010仍然可以设置读取锁。

    本文选自华清远见嵌入式培训教材《从实践中学嵌入式Linux应用程序开发》

   热点链接：

   1、底层文件I/O操作的系统调用
   2、Linux中的文件及文件描述符
   3、Linux文件系统之虚拟文件系统（VFS）
   4、嵌入式文件系统构建
   5、Linux系统调用及用户编程接口(API)

更多新闻>>