UNIXC001 文件锁

文件锁

1. 概念

• 进程A打开一个文件，在内核中产生一个struct_file 类型的结构体变量叫fileA， 进程B打开一个文件，在内核中产生一个struct_file 类型的结构体变量叫fileB. fileA和fileB中有文件的路径，通过文件的路径找到inode，然后就可以通过inode来访问对应的数据块。（上图中fileA、B要访问的inode相同）
• 文件锁分为读锁和写锁，又叫共享锁和互斥锁
  • fileA和fileB同时访问inode， 如果fileA对inode进行写， 而fileB对inode进行读。这样就会造成程序的不确定性，fileB读到也许是fileA写之前也许是写之后的。
  • 所以fileA或fileB访问inode时候都会加一把锁，加锁成功才能访问inode，如果fileA先访问的inode，并加的是写锁，那么fileB就无法访问 这个inode（等fileA访问完再访问，或者直接报错）。如果fileA先访问的inode，并加的是读锁， 那么与fileB访问inode互不影响。
• 可以对文件的区域加锁， 也可以对整个文件加锁
  • 区域加锁，也就是对inode对应的数据块某部分进行加锁

2. 锁的使用步骤（针对建议锁 fcntl）

3. fcntl

• 可变参数的内容应该是 struct flock 类型结构体变量的地址
• man 2 fnctl 查看 struct flock 类型结构体成员

struct flock {
    ...
    // 锁定类型， 读锁，写锁， 解锁
    short l_type;    /* Type of lock: F_RDLCK,
                        F_WRLCK, F_UNLCK */
     // 参考位置，SEEK_SET 代表文件开头， SEEK_CUR 代表当前位置， SEEK_END 代表文件尾
    short l_whence;  /* How to interpret l_start:
                        SEEK_SET, SEEK_CUR, SEEK_END */
    // 相对于参考位置的偏移
    off_t l_start;   /* Starting offset for lock */
    off_t l_len;     /* Number of bytes to lock */
   	// 阻塞加锁的进程的pid， 在涉及到 F_GETLK  和 F_OFD_GETLK时用
    pid_t l_pid;     /* PID of process blocking our lock
                        (set by F_GETLK and F_OFD_GETLK) */
    ...
};

3.1 代码示例

• pa.c 对文件的指定区域加读锁

t_file.h

#ifndef T_FILE_H
#define T_FILE_H
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#endif

t_stdio.h

#ifndef T_STDIO_H_
#define T_STDIO_H_
#include <stdio.h>
#define E_MSG(STRING, VAL) do{perror(STRING); return(VAL);}while(0)
#endif

pa.c

#include <t_file.h>
#include <t_stdio.h>
#include <sys/types.h>
#include <dirent.h>
int main(int argc, char* argv[]) {
    struct flock lock;
    // 设置锁结构体的成员
    // 锁的类型是读锁
    lock.l_type = F_RDLCK;
    lock.l_whence=SEEK_SET;
    // 文件开头偏移为0的位置
    lock.l_start=0;
    // 对文件开头向后6个字节进行加锁
    lock.l_len=6;

    // 只读方式打开
    int fd = open(argv[1], O_RDONLY);
    if(fd == -1)E_MSG("open", -1);
    // 对指定文件加读锁
    int f=fcntl(fd, F_SETLK, &lock);
    if(f==-1)E_MSG("fcntl", -1);
    //到这里加读锁成功
    printf("read lock success ...");
    getchar(); //防止锁被解除
    //关闭文件描述符的时候，所有的记录锁都被移除
    close(fd);
}

• pb.c 对文件指定区域加写锁

#include <t_file.h>
#include <t_stdio.h>
#include <sys/types.h>
#include <dirent.h>
int main(int argc, char* argv[]) {
    struct flock lock;
    // 设置锁结构体的成员
    // 锁的类型是写锁
    lock.l_type = F_WRLCK;
    lock.l_whence=SEEK_SET;
    // 文件开头偏移为0的位置
    lock.l_start=0;
    // 对文件开头向后6个字节进行加锁
    lock.l_len=6;

    // 写方式打开
    int fd = open(argv[1], O_RDWR);
    if(fd == -1)E_MSG("open", -1);
    // 对指定文件加写锁， 如果 F_SETLK， 遇到互斥锁直接报错。 如果 F_SETLK，遇到互斥锁等待解锁
    int f=fcntl(fd, F_SETLK, &lock);
    if(f==-1)E_MSG("fcntl", -1);
    //到这里加读锁成功
    printf("write lock success ...");
    getchar(); //防止锁被解除
    //关闭文件描述符的时候，文件描述符上所有的记录锁都被移除
    close(fd);
}

$ gcc pa.c -o pa
$ gcc pb.c -o pb

• 读是共享锁, 如果对一个文件加了读锁的情况下，再加读锁是可以的

• 写是互斥锁， 如果对一个文件加了读锁的情况下，再加写锁就会排斥

• pc.c 测试是否可以对文件的指定区域 加锁，如果不可以，将持有的互斥锁的进程的pid输出到显示器

#include <t_file.h>
#include <t_stdio.h>
#include <sys/types.h>
#include <dirent.h>
int main(int argc, char* argv[]) {
    struct flock lock;
    // 设置锁结构体的成员
    // 锁的类型是读锁
    lock.l_type = F_RDLCK;
    lock.l_whence=SEEK_SET;
    lock.l_start=0;
    lock.l_len=6;

    // 读方式打开
    int fd = open(argv[1], O_RDONLY);
    if(fd == -1)E_MSG("open", -1);

    // 对指定文件测试是否可以加读锁
    //cmd 是 F_GETLK 时， 如果可以加锁(读或写)，lock.l_type被设置为 F_UNLCK
    int f=fcntl(fd, F_GETLK, &lock); 
    if(f==-1)E_MSG("fcntl", -1);
    if(lock.l_type == F_UNLCK) {
        printf("可以加读锁\n");
    } 
    else
    {
       printf("不可以加读锁\n");
       printf("pid: %d\n", lock.l_pid);

    }
    //关闭文件描述符的时候，所有的记录锁都被移除
    close(fd);
}

• 文件被加读锁时可以继续加读锁

• 文件被加写锁时，不可以继续加读锁