Linux文件操作（中）_rlock和wlock-CSDN博客

本文链接：https://blog.csdn.net/STX19980909/article/details/120352330

10.文件锁
读写冲突
期望的访问
读取写入
无人访问 OK OK
文件的某个区域正在被访问多人在读 OK NO
一人在写 NO NO

为了避免在读写同一个文件的同一个区域时发生冲突，进程之间应该遵循以下规则：
如果一个进程正在写，那么其它进程既不能写也不能读。
如果一个进程正在读，那么其它进程不能写但是可以读。
读共享，写独占。

为了避免多个进程在读写同一个文件的同一个区域时发生冲突，操作系统引入了文件锁机制，并把文件锁分读锁和写锁两种，它们区别在于：
读锁：共享锁，对一个文件的特定区域可以同时加多个读锁
写锁：排它锁，对一个文件的特定区域只能加一把写锁
锁模式：加锁->读写->解锁
期望的加锁
读取写入
无任何锁 OK OK
文件的某个区域正在被访问多把读锁 OK NO
一把写锁 NO NO

int fcntl(int fd, F_SETLKW/F_SETLK, struct flock* lock);
^ ^
阻塞非阻塞
struct flock {
short int l_type; // 锁类型
// F_RDLCK/F_WRLCK/F_UNLCK
short int l_whence; // 锁区偏移起点
// SEEK_SET/SEEK_CUR/SEEK_END
off_t l_start; // 锁区偏移
off_t l_len; // 锁区长度(字节数)，0表示锁到尾
pid_t l_pid; // 加锁进程PID，-1表示自动设置
};
对相对于文件头10字节开始的20字节以阻塞模式加读锁。
struct flock lock;
lock.l_type = F_RDLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 10;
lock.l_len = 20;
lock.l_pid = -1;
fcntl(fd, F_SETLKW, &lock);
对相对于当前位置10字节开始到文件尾以非阻塞方式加写锁。
struct flock lock;
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_CUR;
lock.l_start = 10;
lock.l_len = 0;
lock.l_pid = -1;
fcntl(fd, F_SETLK, &lock);
对整个文件解锁。
struct flock lock;
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
lock.l_pid = -1;
fcntl(fd, F_SETLK, &lock);
代码：wlock.c、rlock.c

//wlock.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
// 加写锁
int wlock(int fd, int wait) {
    struct flock lock;
    lock.l_type   = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = 0;
    lock.l_len    = 0;
    lock.l_pid    = -1;
    return fcntl(fd, wait ? F_SETLKW : F_SETLK, &lock);
}
// 解除锁
int ulock(int fd) {
    struct flock lock;
    lock.l_type   = F_UNLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = 0;
    lock.l_len    = 0;
    lock.l_pid    = -1;
    return fcntl(fd, F_SETLK, &lock);
}
int main(int argc, char* argv[]) {
    if (argc < 2) {
        fprintf(stderr, "用法：%s <字符串>\n", argv[0]);
        return -1;
    }
    int fd = open("shared.txt", O_WRONLY | O_CREAT | O_APPEND, 0644);
    if (fd == -1) {
        perror("open");
        return -1;
    }
    /*
    if (wlock(fd, 1) == -1) {
        perror("wlock");
        return -1;
    }
    */
    while (wlock(fd, 0) == -1) {
        if (errno != EACCES && errno != EAGAIN) {
            perror("wlock");
            return -1;
        }
        printf("该文件已被锁定，稍后再试...\n");
        // 空闲处理...
    }
    size_t len = strlen(argv[1]);
    for (size_t i = 0; i < len; ++i) {
        if (write(fd, &argv[1][i], sizeof(argv[1][i])) == -1) {
            perror("write");
            return -1;
        }
        sleep(1);
    }
    if (ulock(fd) == -1) {
        perror("ulock");
        return -1;
    }
    close(fd);
    return 0;
}


//rlock.c
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
// 加读锁
int rlock(int fd, int wait) {
    struct flock lock;
    lock.l_type   = F_RDLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = 0;
    lock.l_len    = 0;
    lock.l_pid    = -1;
    return fcntl(fd, wait ? F_SETLKW : F_SETLK,
        &lock);
}
// 解除锁
int ulock(int fd) {
    struct flock lock;
    lock.l_type   = F_UNLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = 0;
    lock.l_len    = 0;
    lock.l_pid    = -1;
    return fcntl(fd, F_SETLK, &lock);
}
int main(void) {
    int fd = open("shared.txt", O_RDONLY);
    if (fd == -1) {
        perror("open");
        return -1;
    }
    /*
    if (rlock(fd, 1) == -1) {
        perror("rlock");
        return -1;
    }
    */
    while (rlock(fd, 0) == -1) {
        if (errno != EACCES && errno != EAGAIN) {
            perror("rlock");
            return -1;
        }
        printf("该文件已被锁定，稍后再试...\n");
        // 空闲处理...
    }
    char buf[1024];
    ssize_t readed;
    while ((readed = read(fd, buf, sizeof(buf))) > 0)
        write(STDOUT_FILENO, buf, readed);
    /*
    char buf[1];
    ssize_t readed;
    while ((readed = read(fd, buf, sizeof(buf))) > 0) {
        write(STDOUT_FILENO, buf, readed);
        sleep(1);
    }
    */
    printf("\n");
    if (readed == -1) {
        perror("read");
        return -1;
    }
    if (ulock(fd) == -1) {
        perror("ulock");
        return -1;
    }
    close(fd);
    return 0;
}

测试对文件的某个区域是否可以加某种锁，如果不能加锁，是什么原因导致加锁冲突？
int fcntl(int fd, F_GETLK, struct flock* lock);
成功返回0，失败返回-1。
调用该函数时，lock参数表示欲加之锁的细节。函数成功返回时，通过lock参数输出欲加之锁是否可加，以及存在冲突的锁信息。
代码：lock1.c、lock2.c

//lock1.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
// 加读锁
int rlock(int fd, off_t start, off_t len, int wait) {
    struct flock lock;
    lock.l_type   = F_RDLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl(fd, wait ? F_SETLKW : F_SETLK, &lock);
}
// 加写锁
int wlock(int fd, off_t start, off_t len, int wait) {
    struct flock lock;
    lock.l_type   = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl(fd, wait ? F_SETLKW : F_SETLK, &lock);
}
// 解除锁
int ulock(int fd, off_t start, off_t len) {
    struct flock lock;
    lock.l_type   = F_UNLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl(fd, F_SETLK, &lock);
}
int main(void) {
    printf("进程标识(PID)：%d\n", getpid());
    int fd = open("shared.txt", O_RDWR | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        perror("open");
        return -1;
    }
    const char* text = "ABCDEFGHIJKLMNOPQRST";
    if (write(fd, text, strlen(text) * sizeof(text[0])) == -1) {
        perror("write");
        return 0;
    }
    printf("对EFGH加读锁");
    if (rlock(fd, 4, 4, 0) == -1) {
        printf("失败：%m\n");
        return -1;
    }
    printf("成功！\n");
    printf("对MNOP加写锁");
    if (wlock(fd, 12, 4, 0) == -1) {
        printf("失败：%m\n");
        return -1;
    }
    printf("成功！\n");
    printf("按<回车>，解锁MN...");
    getchar();
    ulock(fd, 12, 2);
    printf("按<回车>，解锁EFGH...");
    getchar();
    ulock(fd, 4, 4);
    close(fd);
    return 0;
}

//lock2.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
// 打印锁
void plock(struct flock lock) {
    if (lock.l_type == F_UNLCK)
        printf("没有锁。\n");
    else {
        printf("%d进程", lock.l_pid);
        switch (lock.l_whence) {
            case SEEK_SET:
                printf("在距文件头");
                break;
            case SEEK_CUR:
                printf("在距当前位置");
                break;
            case SEEK_END:
                printf("在距文件尾");
                break;
        }
        printf("%ld字节处，为%ld字节加了",
            lock.l_start, lock.l_len);
        switch (lock.l_type) {
            case F_RDLCK:
                printf("读锁。\n");
                break;
            case F_WRLCK:
                printf("写锁。\n");
                break;
        }
    }
}
// 测读锁
int rtest(int fd, off_t start, off_t len) {
    struct flock lock;
    lock.l_type   = F_RDLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    if (fcntl(fd, F_GETLK, &lock) == -1)
        return -1;
    plock(lock);
    return 0;
}
// 测写锁
int wtest(int fd, off_t start, off_t len) {
    struct flock lock;
    lock.l_type   = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    if (fcntl(fd, F_GETLK, &lock) == -1)
        return -1;
    plock(lock);
    return 0;
}
// 加读锁
int rlock(int fd, off_t start, off_t len, int wait) {
    struct flock lock;
    lock.l_type   = F_RDLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl(fd, wait ? F_SETLKW : F_SETLK,
        &lock);
}
// 加写锁
int wlock(int fd, off_t start, off_t len, int wait) {
    struct flock lock;
    lock.l_type   = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl(fd, wait ? F_SETLKW : F_SETLK, &lock);
}
// 解除锁
int ulock(int fd, off_t start, off_t len) {
    struct flock lock;
    lock.l_type   = F_UNLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start  = start;
    lock.l_len    = len;
    lock.l_pid    = -1;
    return fcntl(fd, F_SETLK, &lock);
}
int main(void) {
    int fd = open("shared.txt", O_RDWR);
    if (fd == -1) {
        perror("open");
        return -1;
    }
    printf("对CDEF测读锁。");
    if (rtest(fd, 2, 4) == -1) {
        printf("失败：%m\n");
        return -1;
    }
    printf("对CDEF加读锁");
    if (rlock(fd, 2, 4, 0) == -1)
        printf("失败：%m\n");
    else {
        printf("成功！\n");
        ulock(fd, 2, 4);
    }
    printf("对CDEF测写锁。");
    if (wtest(fd, 2, 4) == -1) {
        printf("失败：%m\n");
        return -1;
    }
    printf("对CDEF加写锁");
    if (wlock(fd, 2, 4, 0) == -1)
        printf("失败：%m\n");
    else {
        printf("成功！\n");
        ulock(fd, 2, 4);
    }
    printf("对KLMN测读锁。");
    if (rtest(fd, 10, 4) == -1) {
        printf("失败：%m\n");
        return -1;
    }
    printf("对KLMN加读锁");
    if (rlock(fd, 10, 4, 0) == -1)
        printf("失败：%m\n");
    else {
        printf("成功！\n");
        ulock(fd, 10, 4);
    }
    printf("对KLMN测写锁。");
    if (wtest(fd, 10, 4) == -1) {
        printf("失败：%m\n");
        return -1;
    }
    printf("对KLMN加写锁");
    if (wlock(fd, 10, 4, 0) == -1)
        printf("失败：%m\n");
    else {
        printf("成功！\n");
        ulock(fd, 10, 4);
    }
    printf("等待KLMN上的写锁被解除...\n");
    printf("对KLMN加写锁");
    if (wlock(fd, 10, 4, 1) == -1)
        printf("失败：%m\n");
    else {
        printf("成功！\n");
        ulock(fd, 10, 4);
    }
    close(fd);
    return 0;
}

v节点
i节点内容
锁表指针指向锁表（链表） ->锁节点->锁节点->...
... 锁节点包含信息：锁的类型，锁区偏移，锁区大小，加锁进程的PID

每次对给定文件的特定区域加锁，都会通过fcntl函数向系统内核传递flock结构体，该结构体中包含了有关锁的一些细节，诸如锁的类型、锁区的起始位置和大小，甚至加锁进程的PID(填-1由系统自动设置)。系统内核会收集所有进程对该文件所加的各种锁，并把这些flock结构中的信息，以链表的形式组织成一张锁表，其起始地址就保存在该文件的v节点中。任何一个进程通过fcntl函数对该文件加锁，系统内核都要遍历这张锁表，一旦发现有与欲加之锁构成冲突的锁即阻塞或报错，否则即将欲加之锁插入锁表，而解锁的过程实际上就是调整或删除锁表中的相应节点。
文件锁属于劝谏锁，亦称协议锁。