42-使用flock文件锁

最新推荐文章于 2024-05-17 18:38:39 发布
最新推荐文章于 2024-05-17 18:38:39 发布
阅读量2.1k 收藏 4
点赞数
分类专栏： linux编程修炼心法 文章标签： 文件锁 flock函数 linux编程 进程间通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35733751/article/details/82932036
版权

1. flock函数

flock函数是专门用于实现对文件加锁的，与fcntl不同的是，flock系统调用最初是源自BSD的，而fcntl则是源自System V，flock是对整个文件进行加锁，而fcntl不仅可以对整个文件加锁，还可以对文件部分区域加锁，更加具有灵活性。

 flock - apply or remove an advisory lock on an open file

从flock函数的语义上来看，flock提供的文件锁是一种“建议性”锁，并非强制使用。也就是说，一个进程对文件进行读写操作时可以忽略文件锁的限制，但是如果要保证文件中的数据不会出现问题，所有访问文件的进行都必须加锁。

函数原型：

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

返回值说明：成功返回0，失败返回-1并设置errno错误

参数fd：指定要加锁的文件描述符

参数operation：指定对文件锁的操作，即加锁或解锁。例如LOCK_SH（共享锁），LOCK_EX（互斥锁），LOCK_UN（解锁），LOCK_NB（非阻塞加锁）等。

 

LOCK_SH（共享锁）：如果operation指定了LOCK_SH，当有多个进程对文件进行加锁都会成功，并实现对文件的读操作，相当于多线程里的读写锁。

LOCK_EX（互斥锁）：同一时刻只能有一个线程能加锁成功，并对文件进行读写操作，相当于多线程里互斥量。

LOCK_NB（非阻塞加锁）：LOCK_NB是以非阻塞方式进行加锁，可以和LOCK_EX或LOCK_SH配合使用，如果加锁失败不会阻塞，而是出错返回。

 

2. flock加锁类型的兼容性

当多个进程对文件进行加锁时，无论是以读、写、或读写哪种方式，都可以在对文件设置共享锁或互斥锁，使用不同类型的锁对文件加锁可能产生不同的情况。

图1 - flock加锁类型的兼容性

 

以LOCK_SH方式加锁时，进程A和进程B都能加锁成功，都能成功操作文件，因为锁类型兼容。其他情况加锁都是不兼容的，只有第一个进程能加锁成功，也只有第一个进程能操作文件，后面其他加锁的进程将会阻塞，直到第一个进程释放锁，后面的进程才有可能会加锁成功。 

 

3. flock加锁类型兼容实验

 

进程A

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

int main(int argc , char *args[])
{
        int lock_fd;
        int ret;
        int i = 0;

        if(argc < 2){
                puts("argc < 2");
                exit(1);
        }

        //1 ：共享锁
        //2 : 互斥锁
        int n = atoi(args[1]);


        //打开文件
        lock_fd = open("test.txt" , O_RDONLY | O_CREAT , 0664);
        if(lock_fd < 0){
                perror("open error: ");
                exit(1);
        }


        //以LOCK_SH方式加锁
        if(n == 1){
                ret = flock(lock_fd , LOCK_SH);
                if(ret < 0){
                        perror("flock error :");
                        puts("A is lock LOCK_SH fail");
                        exit(-1);
                }
                puts("A is lock LOCK_SH succesful");

        }else{

                //以LOCK_EX方式加锁
                ret = flock(lock_fd , LOCK_EX);
                if(ret < 0){
                        perror("flock error :");
                        puts("A is lock LOCK_EX fail");
                        exit(-1);
                }
                puts("A is lock LOCK_EX succesful");
        }

        //加锁成功后，打印hello
        for(i = 0; i < 5; i++){
                puts("hello");
                sleep(2);
        }

        //解锁
        ret = flock(lock_fd , LOCK_UN);
        if(ret < 0){
                perror("flock error:" );
        }

        if(n == 1){
                puts("A is unlock LOCK_SH");
        }else{
                puts("A is unlock LOCK_EX");
        }
        return 0;
}

 

进程B

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

int main(int argc , char *args[])
{
        int lock_fd;
        int ret;
        int i = 0;

        if(argc < 2){
                puts("argc < 2");
                exit(1);
        }

        //1 ：共享锁
        //2 : 互斥锁
        int n = atoi(args[1]);

        lock_fd = open("test.txt" , O_RDONLY | O_CREAT , 0664);
        if(lock_fd < 0){
                perror("open error: ");
                exit(1);
        }

        //以LOCK_SH方式加锁
        if(n == 1){
                ret = flock(lock_fd , LOCK_SH);
                if(ret < 0){
                        perror("flock error :");
                        puts("B is lock LOCK_SH fail");
                        exit(-1);
                }
                puts("B is lock LOCK_SH succesful");

        }else{
                //以LOCK_EX方式加锁
                ret = flock(lock_fd , LOCK_EX);
                if(ret < 0){
                        perror("flock error :");
                        puts("B is lock LOCK_EX fail");
                        exit(-1);
                }
                puts("B is lock LOCK_EX succesful");
        }

        //加锁成功后打印world
        for(i = 0; i < 5; i++){
                puts("world");
                sleep(2);
        }

        //解锁
        ret = flock(lock_fd , LOCK_UN);
        if(ret < 0){
                perror("flock error:" );
        }

        if(n == 1){
                puts("B is unlock LOCK_SH");
        }else{
                puts("B is unlock LOCK_EX");
        }
        return 0;
}

进程A以LOCK_SH（共享锁）方式加锁，进程B以LOCK_SH（共享锁）方式加锁：

多个进程以LOCK_SH（共享锁）方式对文件加锁都能成功 

 

 

进程A以LOCK_SH（共享锁）方式加锁，进程B以LOCK_EX（互斥锁）方式加锁：

进程A和进程B两个进程加锁不兼容，只有第一个加锁的进程才会成功，进程B加锁失败会阻塞，直到进程A释放锁为止。

 

4. 指定LOCK_NB非阻塞加锁

在3小节的示例程序中，多个进程对文件进行加锁时，如果锁的类型不兼容，只有第一个进程会加锁成功，其他进程可能会因此阻塞。

例如进程A以LOCK_SH方式加锁成功后，进程B调用flock以LOCK_EX方式加锁时会阻塞，然后等待进程A释放锁，如果指定了LOCK_NB选项，那么进程B不会阻塞，而是出错返回并设置errno为EWOULDBLOCK错误。

 

现在对进程B的代码做以下修改：

//以LOCK_EX方式加锁，并指定LOCK_NB非阻塞
ret = flock(lock_fd , LOCK_EX | LOCK_NB);
if(ret < 0){
      //进一步判断是否为EWOULDBLOCK错误
      if(errno == EWOULDBLOCK){
             puts("errno is return EWOULDBLOCK");
             exit(1);
      }
      perror("flock error :");
      puts("B is lock LOCK_EX fail");
      exit(-1);
}

 

进程A以LOCK_SH（共享锁）方式加锁，进程B以LOCK_EX（互斥锁）方式加锁，程序执行结果如下：

当进程B在指定了LOCK_NB选项，以非阻塞方式加锁失败后不会阻塞，而是立马出错返回。

 

5. flock加锁可能出现的问题

如果一个进程调用flock对文件以LOCK_SH方式加锁时，接着再次调用flock以LOCK_EX方式加锁会将原来的共享锁转换为一个互斥锁，但是这个转换过程并不是原子操作。因为在转换过程中会删除先前持有的共享锁，然后再创建一个新的互斥锁，但是在这个转换过程中可能会让另一个阻塞的进程加锁成功。

 

举个栗子：

A和B两个进程对同一文件进行加锁，B进程以LOCK_SH方式加锁成功，A进程以LOCK_EX方式加锁默认情况下会阻塞，此时B进程再次调用flock以LOCK_EX方式加锁就会将原来的共享锁转换为一个互斥锁，但在这个转换过程中可能会让A进程加锁成功（可能会发生）。

 

如果发生了这种情况，而且B进程没有指定LOCK_NB的话，转换过程将会阻塞，如果指定了LOCK_NB，那么转换过程将会失败并丢失原来已持有的锁（在最初的BSD flock实现和大多数unix实现会出现这样的情况）。

 

示例程序如下：

 

A进程

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

int main(void)
{
        int lock_fd;
        int ret;
        int i = 0;

        //打开文件
        lock_fd = open("test.txt" , O_RDONLY | O_CREAT , 0664);
        if(lock_fd < 0){
                perror("open error: ");
                exit(1);
        }

        //以LOCK_EX，以阻塞方式加锁
        ret = flock(lock_fd , LOCK_EX);
        if(ret < 0){
                puts("A is lock LOCK_EX fail");
                exit(-1);
        }
        puts("A is lock LOCK_EX succesful");

        for(i = 0; i < 5; i++){
                puts("AAAAAAAAA");
                sleep(2);
        }

        //解锁
        ret = flock(lock_fd , LOCK_UN);
        if(ret < 0){
                perror("flock error:" );
        }
        puts("A is unlock LOCK_UN succesful");
        return 0;
}

 

B进程

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

int main(void)
{
        int lock_fd;
        int ret;
        int i = 0;

        //打开文件
        lock_fd = open("test.txt" , O_RDONLY | O_CREAT , 0664);
        if(lock_fd < 0){
                perror("open error: ");
                exit(1);
        }

        //以LOCK_SH方式加锁
        ret = flock(lock_fd , LOCK_SH);
        if(ret < 0){
                if(errno == EWOULDBLOCK){
                        puts("errno is return EWOULDBLOCK");
                        exit(1);
                }

                puts("B is lock LOCK_SH fail");
                exit(-1);
        }

        puts("B is lock LOCK_SH succesful");

        //等待进程A加锁，然后阻塞
        sleep(3);

        //在转换过程中，可能会让阻塞的进程A加锁成功
        ret = flock(lock_fd , LOCK_EX);
        if(ret < 0){
                if(errno == EWOULDBLOCK){
                        puts("errno is return EWOULDBLOCK");
                        exit(1);
                }

                puts("B is lock LOCK_EX fail");
                exit(-1);
        }
        puts("------lock is change LOCK_EX--------");

        puts("B is lock LOCK_EX succesful");


        for(i = 0; i < 5; i++){
                puts("BBBBBBBBB");
                sleep(2);
        }

        //解锁
        ret = flock(lock_fd , LOCK_UN);
        if(ret < 0){
                perror("flock error:" );
        }
        puts("B is unlock LOCK_EX succesful");
        return 0;
}

 程序执行结果：

从程序的执行结果来看，B进程在转换过程中并没有发生之前所说的这种情况。

 

6. flock加锁和C标准库I/O

由于C标准库I/O调用会在用户空间缓存，因此在使用flock加锁中调用C标准库I/O函数可能出现的问题：

  1. 在加锁之前，可能用户空间缓存已经被填满
  2. 锁被删除之后，可能会刷新户空间缓存

 

解决的办法就是：

  1. 使用read或write系统调用取代C标准库I/O调用
  2. 在对文件加锁后立即刷新缓存，释放锁之前再次刷新缓存

 

7. flock的限制

 

1. flock是一种“建议性”锁，可能会导致其他进程不加锁访问文件。

2. 很多NFS（Network File System）即网络文件系统并不支持flock文件加锁

3. flock只能对整个文件加锁，加锁的粒度较大，不利于协作进程之间的并发。例如多个进程访问文件的各个不同部分，这种不必要的加锁会阻碍进程的并发操作。

 

由于历史问题，linux NFS并不支持flock锁，所以综合以上这些原因，在linux中并不推荐使用flock对文件加锁。而是使用fcntl对文件加锁。

C/C++ 单链表逆置算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-08 2816
单链表逆置算法是指将一个单链表中的节点顺序反转。单链表逆置算法的优点是简单易懂、实现较为直接。
对单链表实现就地逆置算法
04-17
对以单链表为存储结构的表实现就地逆置，即在原有空间上实现逆置，不开辟新空间
单链表的就地逆置.
zebinxie的专栏
12-19 8661
　　分析：　　可以用交换数据的方式来达到逆置的目的。但是由于是单链表，数据的存取不是随机的，因此算法效率太低。可以利用指针改指来达到表逆置的目的。具体情况入下：　　(1)当链表为空表或只有一个结点时，该链表的逆置链表与原表相同。　　(2)当链表含2个以上结点时，可将该链表处理成只含第一结点的带头结点链表和一个无头结点的包含该链表剩余结点的链表。然后，将该无头结点链表中的所有结点顺着链表指针，由前往
单链表就地逆置
douxianer
10-07 6822
算法分析 利用指针改指来实现表逆置。 当链表为空的时候，就是它本身 当链表有两个以上结点的时候，将链表处理为只含有一个结点的带头结点链表，和剩余结点组成的链表 操作：通过指针改指实现 1.当链表为空或只含有一个结点时，链表逆置与原链表相同； 2.当含有两个或两个以上结点时，将链表处理成只含第一个结点的带头结点链表和一个无头结点的包含剩余结点的链表，然后从无头结点的链表上摘下，头插*/ #include<stdio.h> #include <stdlib.h> ..
单链表的就地逆置
热门推荐
赞美月亮的专栏
11-07 9万+
单链表的就地逆置是指辅助空间O(1)的逆置方法，有两种方法：普通循环（头插法重新建立带头节点的新链表）和递归。下面我们详细介绍这两种方法：方法一：头插法算法思想：逆置链表初始为空，表中节点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空。void converse(LinkList *head) { Lin...
单链表就地逆置的方法
10-31
### 单链表就地逆置的方法 #### 知识点概述 在计算机科学与数据结构领域中，链表是一种常见的线性数据结构，由一系列节点组成，每个节点包含一个数据元素以及指向下一个节点的指针。对于单链表而言，每个节点只有...
【数据结构】单链表逆置（详解）————四种方法
最新发布
lzh20040919的博客
05-17 1529
逆置就是把最后一个数据提到最前面，倒数第二个放到第二个……依次类推，直到第一个到最后一个。由于链表没有下标，所以不能借助下标来实行数据的逆置，要靠空间的转移来完成链表的逆置，这里采用没有头节点的链表来实现逆置。
单链表第五题（带头节点单链表就地逆置）
loveajiao的博客
06-27 249
5.试编写算法将带头节点的单链表就地逆置，所谓”就地“是指辅助空间复杂度为O（1）。
单链表的就地逆置与删除
03-25
单链表操作就地逆置删除mink到maxk之间的元素#include<stdio.h>
单链表的就地逆置(头插,就地,递归)
qq_40529035的博客
05-07 6481
http://blog.csdn.net/lycnjupt/article/details/47103433https://blog.csdn.net/v_xchen_v/article/details/53067448单链表的就地逆置是指辅助空间O(1)的逆置方法，有两种方法：普通循环（头插法重新建立带头节点的新链表）和递归。下面我们详细介绍这两种方法：方法一：头插法算法思想：逆置链表初始为空，...
【AU】单链表就地逆置
零碎@流年絮语 的博客
08-07 917
单链表的就地逆置是指辅助空间O(1)的逆置方法，有两种方法： 第一种 普通循环（头插法重新建立带头节点的新链表） 第二种 递归
对单链表实现就地逆置
qq_47991812的博客
11-27 3630
对单链表实现就地逆置 /* 对单链表实现就地逆置 */ #include <stdio.h> #include "malloc.h" typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList;//线性链表类型 //逆置 //先把头结点后一个结点i放在末尾，然后在之前末尾结点和当前末尾结点i之间插入结点如：1 2 3 4 -->2 3 4 1 --> 4 3 2 1 vo...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值