Linux 文件锁 - fcntl

最新推荐文章于 2024-04-26 16:31:32 发布
最新推荐文章于 2024-04-26 16:31:32 发布
阅读量1.6k 收藏 7
点赞数 1
分类专栏： Linux 文章标签： linux 文件锁 C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cpp_learner/article/details/127972630
版权

什么是文件锁？

即锁住文件，不让其他程序对文件做修改！

为什么要锁住文件？

案例，有两个程序，都对一个文件做写入操作。

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

#define FILE_NAME       "flock_demo.txt"


int main(void) {
    int fd = -1;
    char buf[64] = "hello, data one!\n";    // 程序1写入文件内容
    //char buf[64] = "hi, data two!\n";     // 程序2写入文件内容

    fd = open(FILE_NAME, O_RDWR|O_CREAT, 00666);
    if (fd < 0) {
        fprintf(stderr, "open file %s failed! reason: %s\n", FILE_NAME, strerror(errno));
        exit(-1);
    }

    int ret = write(fd, buf, sizeof(buf));
    if (-1 == ret) {
        fprintf(stderr, "write failed. reason: %s\n", strerror(errno));
        exit(-2);
    }

    printf("write successful! start sleep 10s...\n");
    sleep(10);

    close(fd);
    return 0;
}

程序1对文件flock_demo.txt写入hello, data one!

程序2对文件flock_demo.txt写入hi, data two!

然后都睡眠10秒后才调用close函数关闭文件，然后程序结束；

首先运行程序1，然后运行程序2，来看看运行后的文件结果！

 根据图片测试结果可知，程序1先将hello, data one!写入文件，然后睡眠10秒钟；然后程序2将hi, data two!写入文件，将程序1写入的内容给覆盖掉了，然后睡眠10秒；10秒后程序1执行close函数关闭文件退出程序，10秒后程序2执行close函数关闭文件退出程序。

但此时文件内容保存的是程序2写入的内容，程序1的调用者肯定就会很纳闷了，为什么我调用程序应该要写入hello, data one!才对，它为什么写入了hi, data two!呢？

如果此时程序1执行一次，而程序二不执行，那么程序1就可以正常将hello, data one!写入到文件中去，那么程序1的调用就很懵逼了，百思不得其解。。。

基于以上情况，我们操作文件前需要使用文件锁！

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

int fcntl (int fd, int cmd, ... /* arg */ );

描述：文件上锁、解锁等。

 fd:

        文件描述符；

cmd：

        取值  F_GETLK,   F_SETLK 和 F_SETLKW，分别表示获取锁、设置锁和同步设置锁.

返回值：

        成功： 返回 0；或者返回：F_DUPFD、F_GETFD、F_GETFL、F_GETLEASE、F_GETOWN、F_GETSIG、F_GETPIPE_SZ；对于一个成功的调用，返回值取决于操作；

        失败： 返回 -1，并且设置错误编号 errno ，可用( strerror(errno) ) 查看. 

文件锁的表示

struct flock {

    short l_type;    /* Type of lock: F_RDLCK, F_WRLCK, F_UNLCK */

    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_t l_pid;     /* PID of process blocking our lock(F_GETLK only) */
};

l_type 有三种状态: 
F_RDLCK        设置读锁 
F_WRLCK       设置写锁
F_UNLCK        设置解锁


l_whence 也有三种方式: 
SEEK_SET 以文件开头为锁定的起始位置。 
SEEK_CUR 以目前文件读写位置为锁定的起始位置 
SEEK_END 以文件结尾为锁定的起始位置。 

// struct flock 结构体说明

struct flock {

    short l_type;          /*F_RDLCK, F_WRLCK, or F_UNLCK */

    off_t l_start;           /*offset in bytes, relative to l_whence */

    short l_whence;    /*SEEK_SET, SEEK_CUR, or SEEK_END */

    off_t l_len;            /*length, in bytes; 0 means lock to EOF */

    pid_t l_pid;           /*returned with F_GETLK */

};

l_type:  第一个成员是加锁的类型：只读锁，读写锁，或是解锁。

l_start和l_whence: 用来指明加锁部分的开始位置。

l_len: 是加锁的长度。设0表示对整个文件加锁。

l_pid: 是加锁进程的进程id。

举例：

我们现在需要把一个文件的前三个字节加读锁，则该结构体的l_type=F_RDLCK, l_start=0,

l_whence=SEEK_SET,  l_len=3,  l_pid=-1，然后调用fcntl函数时，

cmd参数设F_SETLK.

1. 文件上锁

struct flock fflock;
memset(&fflock, 0, sizeof(struct flock));

// 上锁
fflock.l_type = F_WRLCK;        /* 写锁 */
//fflock.l_type = F_RDLCK;      /* 读锁 */

fflock.l_whence = SEEK_SET;    
fflock.l_start = 0;
fflock.l_len = 0;    // 为0，锁整个文件
fflock.l_pid = -1;

// 上锁或解锁，判断是否成功
//if (fcntl(fd, F_SETLKW, &fflock) < 0) {
if (fcntl(fd, F_SETLK, &fflock) < 0) {
    fprintf(stderr, "set file lock failed! reason: %s\n", strerror(errno));
    return -1;
}

2. 文件解锁

struct flock fflock;
memset(&fflock, 0, sizeof(struct flock));

fflock.l_type = F_UNLCK;    // 解锁
fflock.l_whence = SEEK_SET;    
fflock.l_start = 0;
fflock.l_len = 0;    // 为0，解锁整个文件
fflock.l_pid = -1;


// 上锁或解锁，判断是否成功
//if (fcntl(fd, F_SETLKW, &fflock) < 0) {
if (fcntl(fd, F_SETLK, &fflock) < 0) {
    fprintf(stderr, "set file lock failed! reason: %s\n", strerror(errno));
    return -1;
}

3. 获取文件是否上锁

struct flock fflock;
memset(&fflock, 0, sizeof(struct flock));

// 获取当前文件是否已经上锁
int ret = fcntl(fd, F_GETLK, &fflock);    // F_GETLK
if (-1 == ret) {
    fprintf(stderr, "fcntl get lock failed! reason: %s\n", strerror(errno));
    return -1;
}

// 文件已上锁
if (fflock.l_type != F_UNLCK) {

    if (fflock.l_type == F_RDLCK) {    // 文件已上读锁
        printf("flock has been set to read lock by %d\n", fflock.l_pid);
        // return;        

    } else if (fflock.l_type == F_WRLCK) {    // 文件已上写锁
        printf("flock has been set to write lock by %d\n", fflock.l_pid);
        // return;
    }
    
    return -1;
}

例：

#include <unistd.h>
#include <fcntl.h>      // file lock
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

#define FILE_NAME       "flock_demo.txt"

int flock_set(int fd, int type) {
    // 获取当前进程id
    printf("pid = %d come in.\n", getpid());

    struct flock fflock;
    memset(&fflock, 0, sizeof(struct flock));

    // 获取当前文件是否已经上锁
    int ret = fcntl(fd, F_GETLK, &fflock);
    if (-1 == ret) {
       fprintf(stderr, "fcntl get lock failed! reason: %s\n", strerror(errno));
       return -1;
    }

    // 文件已上锁
    if (fflock.l_type != F_UNLCK) {
        if (fflock.l_type == F_RDLCK) {
            printf("flock has been set to read lock by %d\n", fflock.l_pid);
        } else if (fflock.l_type == F_WRLCK) {
            printf("flock has been set to write lock by %d\n", fflock.l_pid);
        }
        return -1;

    }


    // lock file
    fflock.l_type = type;
    fflock.l_whence = SEEK_SET;
    fflock.l_start = 0;
    fflock.l_len = 0;
    fflock.l_pid = -1;

    // 上锁或解锁，判断是否成功
    //if (fcntl(fd, F_SETLKW, &fflock) < 0) {
    if (fcntl(fd, F_SETLK, &fflock) < 0) {
        fprintf(stderr, "set file lock failed! reason: %s\n", strerror(errno));
        return -1;
    }

    switch(fflock.l_type) {
        case F_RDLCK: {
            printf("read lock is set by %d\n", getpid());
        }
        break;

        case F_WRLCK: {
            printf("write lock is set by %d\n", getpid());
        }
        break;

        case F_UNLCK: {
            printf("lock is released by %d\n", getpid());
        }
        break;

        default:
        break;
    }

    printf("Process pid = %d out.\n", getpid());
    return 0;
}


int main(void) {
    int fd = -1;

    fd = open(FILE_NAME, O_RDWR|O_CREAT, 00666);
    if (fd < 0) {
        fprintf(stderr, "open file %s failed! reason: %s\n", FILE_NAME, strerror(errno));
        exit(-1);
    }

    // 1.F_WRLCK
    int ret = flock_set(fd, F_WRLCK);   // 写锁
    //int ret = flock_set(fd, F_WRLCK); // 读锁
    if (-1 != ret) {
        getchar();

        // 2.F_UNLCK
        flock_set(fd, F_UNLCK);
        getchar();
    }

    close(fd);
    return 0;
}

用以上的代码编译一个读锁程序，编译一个写锁程序：

main函数中替换以下代码进行编译

int ret = flock_set(fd, F_WRLCK);   // 写锁
int ret = flock_set(fd, F_WRLCK);   // 读锁

gcc file_lock.c -o file_w_lock
gcc file_lock.c -o file_r_lock

1. 设置锁使用：F_SETLK

情况一：读锁 和 读锁

 结论：可以看出，两个程序都可以对文件进行加读锁！

情况二：读锁 和 写锁

结论：当文件上读锁后，就无法再给文件上写锁，且也无法检测处文件上锁状态；

即(./file_w_lock)执行代码  int ret = fcntl(fd, F_GETLK, &fflock);  后，其 fflock.l_type != F_UNLCK ，所以没法做中断操作；下面再对文件进行上锁操作，就函数返回-1了！

情况三：写锁 和 读锁

 结论：文件上写锁后，再给文件上读锁，可以被检测出来文件已经上锁了，程序就返回结束了

情况四：写锁 和 写锁

 结论：文件上写锁后，再给文件上写锁，可以被检测出来文件已经上锁了，程序就返回结束了

2. 设置锁使用：F_SETLKW

使用F_SETLKW会有等待阻塞的情况！

情况一：读锁 和 读锁

结论：可以看出，两个程序都可以对文件进行加读锁！ 

情况二：读锁 和 写锁

先给文件上读锁，再个文件上写锁，此时上写锁程序在获取文件的上锁状态时，被阻塞在此等待；

当我们在程序1那里按下回车键后，对文件解锁；右边程序就可以正常对文件上写锁了；否则会一直阻塞。。。

情况三：写锁 和 读锁

 文件上写锁后，再给文件上读锁，可以被检测出来文件已经上写锁了，程序就返回结束了

情况四：写锁 和 写锁

结论：文件上写锁后，再给文件上写锁，可以被检测出来文件已经上写锁了，程序就返回结束了 

3. 其他情况

这里还有另一种情况，就是程序1对文件上锁，程序2没有对文件上锁，然后对文件做写入操作

程序1还是上面的程序代码；

程序2代码如下：

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>

#define FILE_NAME       "flock_demo.txt"


int main(void) {
    int fd = -1;
    char buf[64] = "write file data...\n";

    fd = open(FILE_NAME, O_RDWR|O_CREAT, 00666);
    if (fd < 0) {
        fprintf(stderr, "open file %s failed! reason: %s\n", FILE_NAME, strerror(errno));
        exit(-1);
    }

    int ret = write(fd, buf, sizeof(buf));
    if (-1 == ret) {
        fprintf(stderr, "write failed. reason: %s\n", strerror(errno));
        exit(-2);
    }

    printf("write successful!\n");

    close(fd);
    return 0;
}

gcc file_write.c -o file_write
 

文件上读锁：

程序1给文件上读锁后，程序2依然可以 对文件做写入操作！

文件上写锁：

程序1给文件上写锁后，程序2依然可以对文件做写入操作！

结论：

        由以上两个测试可知，给文件上锁，仅仅对相应也给文件上锁的程序可以限制，对于没有对文件上锁的程序无任何限制！

        所以，在开发中，就得做出规定，大家对文件操作时都得对文件上锁后再进行操作！

总结

        文件上锁的几种情况已经列举出来了，使用时注意一下就行！

cpp_learners
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux编程下的fcntl文件锁代码
05-30
这是在Linux应用编程下的fcntl函数的基础实验，具体看博客：http://blog.csdn.net/mybelief321/article/details/8993138
linux下文件锁使用总结
hsy12342611的专栏
06-15 3486
linux下文件锁使用总结
Linux 文件锁 fcntl 函数详解
tecoes的博客
10-07 612
fcntl() 功能是针对文件描述符提供控制，根据不同的 cmd 对文件描述符可以执行的操作也非常多，用的最多的是文件记录锁，也就是 F_SETLK 命令，此命令搭配 flock 结构体，对文件进行加解锁操作，例如执行加锁操作，如果不解锁，本进程或者其他进程再次使用 F_SETLK 命令访问同一文件则会告知目前此文件已经上锁，加锁进程退出（正常、异常）后会自行解锁，使用此特性可以实现避免程序多次运行、锁定文件防止其他进行访问等操作。如果共享锁或独占锁被其他的锁阻塞，进程将等待直到这个请求能够完成。
linux文件I/O之 fcntl() 函数用法：设置文件的 flags、设置文件锁（记录锁）
天道酬勤
08-12 809
利用 fcntl() 函数获取、设置文件的 flags 和 设置文件锁是在现实开发中比较常用到的功能，比如将一个 socket 设置为非阻塞（O_NONBLOCK）。有时有两个进程对同一个文件进行读写操作时，该文件的最后状态取决于写该文件的最后一个进程。当一个进程正在读写文件的某一区域时，用 fcntl() 函数用 F_SETLK 命令请求对该文件加锁，其他进程就不能对文件的这个区域进行修改操作。
Linux 文件锁的原理、实现和应用
Yang的博客
08-07 5374
一篇文章彻底搞懂Linux 文件锁的原理、实现和应用
Linux文件锁的使用
qq_42174306的博客
11-01 3733
文件是一种共享资源,多个进程对同一文件进行操作的时候,必然涉及到竞争状态，因此引入了文件锁实现对共享资源的访问进行保护的机制，通过对文件上锁， 来避免访问共享资源产生竞争状态。
【Linux高级 I/O（7）】初识文件锁——fcntl()方法及其独占性、共享性实验（附全文代码）
cj_lsk的博客
05-26 1711
如果一个进程对文件的某个区域已经上了一把锁，后来该进程又试图在该区域再加一把锁，那么通常新加的锁将替换旧的锁。如果两个区域出现了重叠，譬如 100~200 字节区间和 150~250 字节区间，150~200 就是它们的重叠部分，一个进程对同一文件的相同区域不可能同时加两把锁，新加的锁会把旧的锁替换掉，譬如先对 100~200 字节区间加写锁、再对 150~250 字节区间加读锁，那么 150~200 字节区间最终是读锁控制的，关于这个问题，大家可以自己去验证、测试。只有当请求的锁可用时，进程才会被唤醒。
linux 文件锁
jiu_yue_ya的博客
09-19 653
当关闭文件时，将释放进程的所有锁定，即使进程仍然有打开的文件。进程使用 flock 尝试锁文件时，如果文件已经被其他进程锁住，进程会被阻塞直到锁被释放掉，或者在调用 flock 的时候，采用 LOCK_NB 参数，在尝试锁住该文件的时候，发现已经被其他服务锁住，会返回错误。flock 锁的释放非常具有特色，即可调用 LOCK_UN 参数来释放文件锁，也可以通过关闭 fd 的方式来释放文件锁（flock 的第一个参数是 fd），意味着 flock 会随着进程的关闭而被自动释放掉。记录锁是更细粒度的文件锁。
Linux fcntl函数
坚持学习
04-21 414
Linux fcntl函数
Python使用文件锁实现进程间同步功能【基于fcntl模块】
01-21
本文实例讲述了Python使用文件锁实现进程间同步功能。分享给大家供大家参考，具体如下： 简介 在实际应用中，会出现这种应用场景：希望shell下执行的脚本对某些竞争资源提供保护，避免出现冲突。本文将通过fcntl模块...
python 利用文件锁单例执行脚本的方法
01-20
在python中，为了实现这个需求，可以引入fcntl模块对文件加一个排他锁，这样一来，先启动的实例拥有了文件锁，而后启动的实例则因无法获取锁而退出 #coding=utf-8 import fcntl, sys, time, os pidfile = 0 def ...
linux fcntl_lock.c
04-06
linux 编程实战，fcntl 文件记录锁的应用实例程序。。。。
fcntl函数的使用详解
12-25
文件锁包括建议性锁和强制性锁。 建议性锁要求每个上锁文件的进程都要检查是否有锁存，并且尊重已有的锁。在一般情况下，内核和系统都不使用建议性锁。强制性锁是由内 核执行的锁，当一个文件被上锁进行写入操作的...
Linux多进程(五) 进程池 C++实现
最新发布
Lyajpunov的博客
04-26 578
进程池是一种并发编程模式，用于管理和重用多个处理任务的进程。它通常用于需要频繁创建和销毁进程的情况，以避免因此产生的开销。减少进程创建销毁的开销：避免频繁创建和销毁进程所带来的系统资源开销。提高系统响应速度：由于进程已经初始化并且一直保持在内存中，可以立即分配执行任务，减少了任务等待时间。控制资源使用：通过限制进程池中的进程数量，可以控制系统资源的使用情况，避免资源过度消耗。
Linux——web服务配置
Xinan_____的博客
04-23 1048
GET：请求获取指定资源的表示形式。使用GET方法，客户端请求服务器发送某个资源。POST：向指定资源提交数据，用于处理表单提交、文件上传等操作。PUT：向指定资源位置上传其最新内容，用于更新资源。DELETE：请求服务器删除指定资源。HEAD：请求获取与实体相对应的头部信息，用于获取资源的元数据。OPTIONS：请求查询服务器支持的HTTP方法。TRACE：请求服务器回显收到的请求消息，用于测试或诊断。200 OK：请求成功。：永久重定向，请求的资源已经被分配了新的。
linux18：进程等待
m0_73919066的博客
04-20 1095
1：子进程创建的目的是要完成父进程指派的某个任务，当子进程运行完毕退出时，父进程需要通过进程等待的方式，回收子进程资源，获取子进程退出信息（子进程有无异常？没有异常结果是否正确？检查退出码查看错误原因）2：父进程如果一直不回收，就可能造成子进程‘僵尸进程’的问题，子进程一直得不到父进程的回收，进而造成内存泄漏。3：子进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力杀死一个已经死去的进程。只能通过进程等待将他进行回收。
Linux之C编程入门
qwertf123的博客
04-21 843
Linux之C编程入门
arm架构Linux5.0内核连接脚本文件vmlinux.lds.S分析
jianjian的博客
04-23 931
vmlinux.lds.S 是 Linux 内核中用于链接的脚本文件，用于定义内核对象文件的内存布局，即它告诉链接器如何将不同的内核代码段和数据段组合成一个最终的内核映像 vmlinux。编译内核源码生成内核文件的过程分两步，一个是“编译”，另一个是“链接”的过程，vmlinux.lds.S要做的就是告诉编译器如何链接编译好的各个内核.o文件，从而生成vmlinux文件。
Linux：Win10平台上，用VMware安装Centos7.x及系统初始化关键的相关配置（分步骤操作，详细，一篇足以）
Brave_heart4pzj的博客
04-22 176
Linux
linux VFS 文件锁
04-18
Linux VFS（Virtual File System）文件锁是用于在多进程或多线程环境下对文件进行并发访问控制的机制。它可以确保同一时间只有一个进程或线程能够对文件进行写操作，从而避免数据的不一致性和竞争条件的发生。 Linux VFS文件锁主要有两种类型：共享锁（读锁）和独占锁（写锁）。共享锁允许多个进程或线程同时对文件进行读操作，而独占锁则只允许一个进程或线程对文件进行写操作。 在Linux中，文件锁是通过fcntl系统调用来实现的。具体而言，可以使用fcntl函数来获取、设置和释放文件锁。fcntl函数的相关参数包括文件描述符、锁类型、锁起始位置和锁长度等。 以下是一些关于Linux VFS文件锁的常见问题及回答： 1. 什么是共享锁和独占锁？ 共享锁（读锁）允许多个进程或线程同时对文件进行读操作，不会阻塞其他进程或线程的读操作。独占锁（写锁）则只允许一个进程或线程对文件进行写操作，其他进程或线程的读写操作都会被阻塞。 2. 如何获取文件锁？ 可以使用fcntl函数来获取文件锁。通过设置fcntl函数的参数，可以指定锁类型、锁起始位置和锁长度等信息。 3. 文件锁的作用是什么？ 文件锁可以确保同一时间只有一个进程或线程能够对文件进行写操作，从而避免数据的不一致性和竞争条件的发生。它在多进程或多线程环境下起到了并发访问控制的作用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cpp_learners

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值