精华内容
下载资源
问答
  • 2022-03-28 20:14:49

    文件锁的读锁和写锁

    对文件加锁时可以加两种锁,分别是“读文件锁”和“写文件锁”,简称读锁和写锁。

    读锁、写锁之间关系

    1. 读锁和读锁共享:可以重复加读锁,别人加了读锁在没有解锁之前,我依然可以加读锁,这就是共享。
    2. 读锁和写锁互斥:别人加了读锁没解锁前,加写锁会失败,反过来也是如此。
      • 加锁失败后两种处理方式:
        • 阻塞,直到别人解锁然后加锁成功为止。
        • 出错返回,不阻塞
    3. 写锁与写锁互斥:别人加了写锁在没有解锁前,不能加写锁,加写锁会失败。
      • 加锁失败后两种处理方式:

        • 阻塞,直到别人解锁然后加锁成功为止
        • 出错返回,不阻塞

    文件的加锁方式

    1. 对整个文件的内容加锁
      对整个文件加锁是最常用的文件加锁方式。
      当你整个文件加锁时,如果文件的长度因为写入新数据或者截短而发生了变化,加锁内容长度会自动变化,保证对内容变化着的整个文件加锁。

    2. 对文件某部分内容加锁

      不过一般来说,对多少内容加锁,就对多少内容解锁。如果你是对整个文件加锁,就将整个文件解锁。

      但是实际上加锁和实际解锁的长度不相同,比如我对1000个字节的内容加了锁,但是只对其中的100字节解锁,不过这种情况用的少,知道怎么回事即可。

      怎么实现文件的整个加锁和区域解锁呢?

      后面再说

    3.  

    再看看fcntl的函数原型

    int fcntl(int fd, int cmd, ... /* struct flock *flockptr */ );

    第三个参数是...,fcntl函数是一个变参函数,第三个参数用不到时就不写

    1. 功能
      fcntl函数有多种功能,我们这里主要介绍实现文件锁的功能,当cmd被设置的是与文件锁相关的宏时,fcntl就是用来实现文件锁。
    2. 参数
      • fd:文件描述符,指向所需要被加锁的文件
      • cmd:实现文件锁时,cmd有三种设置,F_GETLK,F_SETLK和F_SETLKW含义如下:
        1. F_GETLK
          从内核获取文件锁的信息,将其保存到第三个参数,第三个参数struct flock *flockptr,我们这里是要设置文件锁,而不是获取已有的文件锁信息,我们这里用不到这个宏。
        2. F_SETLK
          设置第三个参数所代表的文件锁,而且设置的是非阻塞文件锁,也就是如果加锁失败不会阻塞。也就是说加锁失败后如果不想阻塞的话,就由F_SETLK宏来设置。
          此时,需要用到第三个参数:struct flock *flockptr;
          使用举例:
          1. 第一步:定义一个struct flock flockptr结构体变量(这个结构体变量就是文件锁)。
          2. 第二步:设置flockptr的成员,表示你想设置怎样的文件锁
          3. 第三步:通过第三个参数,将设置好的flockptr的地址传递给fcntl,设置你想要的文件锁
        3. F_SETLKW
          F_SETLKW一样,只不过设置的是阻塞文件锁,也就是说加锁不成功的话就阻塞,是由F_SETLKW宏来决定的。
    3. int fcntl(int fd, int cmd, ... /* struct flock *flockptr */ );
      • 第三个参数
        • 第三个参数设置为什么视情况而定,如果fcntl用于实现文件锁的话,第三个参数为struct flock *flockptr,flockptr代表的就是文件锁。
        • 对flockptr的成员设置为特定的值,就可以将文件锁设置为你想要的锁。
        • struct flock结构体如下:
           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
                                             (set by F_GETLK and F_OFD_GETLK) */
                         ...
          };
          
          

    成员说明:

    • l_type:锁类型

      • F_RDLCK:读锁(或称共享锁)
      • F_WRLCK:写锁
      • F_UNLCK:解锁
    • l_whence:加锁位置粗定位,设置同lseek的whence

      • SEEK_SET:文件开始处
      • SEEK_CUR:文件当前位置处
      • SEEK_END:文件末尾位置处
      • l_whence这个与lseek函数的whence是一个含义
    • l_start:精定位,相对于l_whence的偏移,与lseek的offset的含义完全一致
      通过l_whence和l_start的值,就可以用来指定从文件的什么位置开始加锁,不过一般来说,我们会将l_whence指定为SEEK_SET,l_start指定为0,表示从整个文件头上开始加锁。

    • l_len:从l_whence和l_start所指定的起始地点算起,需要对文件多长的内容加锁。

      如果 l_len被设置0,表示一直加锁到文件结尾,如果文件长度时变化的,将自动调整加锁的末尾位置

      l_whence和l_start设置为SEEK_SET和0,然后再将l_len设置为0,就表示从文件加锁到文件末尾,其实就是对整个文件加锁。

      如果只是对文件中间的某段加锁,这只是区域加锁,加区域锁时可以给文件n多个的独立区域加锁。

    • l_pid:当前正加锁进程的PID

    代码演示

    使用文件锁的互斥操作,解决父子进程向同一文件写"hello",“world\n”时,hello hello world相连的问题。

    头文件,学到了封装函数的思想,尤其是使用宏来实现不同类型的文件锁

    /* Too many parameters ,Different types of locks
     * Write dead!!!!!!!!!
     * */
    /* Set non blocking write lock */
    #define SET_WRFLCK(fd, l_whence, l_start, l_len) \
    		set_filelock(fd, F_SETLK, F_WRLCK, l_whence, l_start, l_len)
    
    /* Set blocking write lock */
    #define SET_WRFLCKW(fd, l_whence, l_start, l_len) \
    		set_filelock(fd, F_SETLKW, F_WRLCK, l_whence, l_start, l_len)
    
    /* Set blocking read lock */
    #define SET_RDFLCKW(fd, l_whence, l_start, l_len) \
    		set_filelock(fd, F_SETLKW, F_RDLCK, l_whence, l_start, l_len)
    
    /* Set nonblocking read lock */
    #define SET_RDFLCK(fd, l_whence, l_start, l_len) \
    		set_filelock(fd, F_SETLK, F_RDLCK, l_whence, l_start, l_len)
    
    /* Unlock */
    #define SET_UNFLCK(fd, l_whence, l_start, l_len) \
    		set_filelock(fd, F_SETLK, F_UNLCK, l_whence, l_start, l_len)
    
    /*Package and set the locking function
     * */
    static void set_filelock(int fd, int ifwait, short l_type, short l_whence, off_t l_start, short l_len) 
    {
    	int ret = 0;
    	struct flock flock;
    
    	flock.l_type = l_type;
    	flock.l_whence = l_whence;
    	flock.l_start = l_start;
    	flock.l_len = l_len;
    
    	ret = fcntl(fd, ifwait, &flock);
    	if (ret == -1)
    	{
    		perror("fcntl");
    		exit(EXIT_FAILURE);
    	}
    }
    
    
    int main(int argc, char *argv[])
    {
    	int fd = 0;
    	int ret = 0;
    
    	fd = open("./hello", O_RDWR|O_CREAT|O_TRUNC, 0664);
    	if (fd == -1)  print_err("./hello", __LINE__, errno); 
    
    	ret = fork();
    	if (ret > 0)
    	{
    		while(1)
    		{
    			SET_WRFLCKW(fd, SEEK_SET, 0, 0);
    			write(fd, "hello ", 6);
    			write(fd, "world\n", 6);
    			SET_UNFLCK(fd, SEEK_SET, 0, 0);
    		}
    	}
    	else if (ret == 0)
    	{
    		while(1)
    		{
    			SET_WRFLCKW(fd, SEEK_SET, 0, 0);
    			write(fd, "hello ", 6);
    			write(fd, "world\n", 6);
    			SET_UNFLCK(fd, SEEK_SET, 0, 0);
    		}
    	}
    	return 0;
    }
    
    

    在hello文件里面使用/hello hello没找到文本内容说明成功了。

    对于fcntl的认识不仅仅可以追加改变文件标志,还可以实现文件锁的功能

    更多相关内容
  • 41-fcntl设置文件锁

    千次阅读 2018-10-02 14:28:01
    1. 文件锁 当多个进程打开同一文件进行读写时可能会出现数据混乱的问题,原因在于进程间共享同一文件读写指针位置,也就是f_pos(关于f_pos参考:4-文件描述符与打开的文件之间的关系的第三小节file结构体)。 ...

    1. 文件锁

    当多个进程打开同一文件进行读写时可能会出现数据混乱的问题,原因在于进程间共享同一文件读写指针位置,也就是f_pos(关于f_pos参考:4-文件描述符与打开的文件之间的关系的第三小节file结构体)。

    解决这个问题的方法有很多,比如可以使用信号量完成进程同步,但通常使用文件锁会更好一些,因为内核会将锁跟文件关联起来,这就需要借助fcntl函数来实现对一个文件进行加锁。只有拿到锁的进程可以对文件进行读写操作,而没有获得锁的进程操作文件可以打开文件,但无法执行read、write操作,以此来防止进程间对同一文件进行读写出现的数据混乱问题。

     

    2. fcntl函数

    #include <unistd.h>
    #include <fcntl.h>
    
    int fcntl(int fd, int cmd, ... /* arg */ );

    参数fd:指定文件描述符

     

    参数cmd:一般用于设置文件锁,F_SETLK和F_SETLKW 用于加锁解锁, F_GETLK用于获取文件锁。

    F_SETLK设置文件锁,如果另一进程已经加锁,那么fcntl将会失败并返回EAGAIN错误,不会阻塞。

    F_SETLKW设置文件锁,如果另一进程已经加锁,那么该进程将会阻塞,直到文件锁被释放。

    F_GETLK实际上是用于获取文件锁的相关信息,以检测能否设置F_SETLK或F_SETLKW进行加锁。

     

    参数flock具体定义:

    struct flock {
        ...
        short l_type;    	//锁的类型:F_RDLCK(读方式加锁) 、F_WRLCK(写方式加锁) 、F_UNLCK(解锁)
        short l_whence;  	//参考偏移位置:SEEK_SET、SEEK_CUR、SEEK_END 
        off_t l_start;   	//具体起始偏移位置,0表示文件开头
        off_t l_len;     	//长度:其实是表示加锁的范围(加多少个字节),如果为0表示整个文件加锁
        pid_t l_pid;     	//持有该锁的进程ID:(只有调用F_GETLK only,才会用到这个参数)
        ...
    };

     

    加锁范围:

    1. 如果 len > 0, [whence+start  ,  whence+start+len) ,包左不包右

    2. 如果 len = 0, [whence+start  , ∞),包左不包右,表示对整个文件加锁

    以whence为参考位置开始,加上start就是具体的起始位置。例如:whence = SEEK_SET,start = 10,那么参考位置就是文件开头(偏移为0的位置),加上start后,具体的起始位置就是偏移为10的位置。

     

    3. 文件锁示例

    多个进程对加锁文件进行访问:

    1. 首先测试两个进程间以读方式加锁

    2. 然后测试两个进程间以写方式加锁

    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    void sys_err(char *str){
        perror(str);
        exit(1);
    }
    
    int main(int argc, char *argv[]) {
        int fd;
        struct flock f_lock;
        //参数不够
        if (argc < 2) {
            printf("./a.out filename\n");
            exit(1);
        }
        //打开文件失败
        if ((fd = open(argv[1] , O_RDWR)) < 0){
    		  sys_err("open");
    	}
        //选用写琐
        f_lock.l_type = F_WRLCK;  
        //选用读琐      
        //f_lock.l_type = F_RDLCK;          
    	
        //设置文件指针为文件开头
        f_lock.l_whence = SEEK_SET;
        //起始偏移,0表示文件开头
        f_lock.l_start = 0;
        // l_len表示加锁的长度,0表示整个文件加锁 
        f_lock.l_len = 0; 
                 
        //设置属性,让线程阻塞(F_SETLKW),直到加锁成功
        fcntl(fd, F_SETLKW, &f_lock);
        //如果加锁成功,打印get flock
        printf("get flock\n");
    
        //为了测试效果明显,休眠10秒
        sleep(10);
    
        //设置锁类型为解锁
        f_lock.l_type = F_UNLCK;
        //设置属性,解锁不成功阻塞
        fcntl(fd, F_SETLKW, &f_lock);
        //解锁成功打印unflock
        printf("un flock\n");
        close(fd);
        return 0;
    }

     

    测试两个进程间以写方式加锁,程序执行结果:

    从图中可以看出,以写方式进行加锁的话,那么左1进程对文件以写方式加锁成功,右1进程对文件以写方式加锁会失败并阻塞,等到左1进程释放写锁后,右1进程立马获取到了写锁。

     

     

    修改部分代码,测试两个进程间以读方式加锁:

    //选用写琐
    //f_lock.l_type = F_WRLCK;  
    //选用读琐      
    f_lock.l_type = F_RDLCK;       

    以读方式进行加锁的话,那么左1进程对文件以读方式加锁成功,右1进程对文件以读方式加锁也会成功。

    由此我们可以得出结论:进程间对文件进行加文件锁也遵循“读共享、写独占”特性。但!如若进程不加锁直接操作文件,依然可访问成功,但数据势必会出现混乱。

     

     

    展开全文
  • python windows 下设置文件锁、多线程

    千次阅读 2020-10-28 10:44:06
    在python 环境的Lib文件夹下新建fcntl.py文件,在其中写入下面的内容: fcntl.py是linux平台上python自带的包,windows平台下没有,所以需要自己设计一份,让windows下引用fcntl功能的程序可以跑通。 参考资料:...

    在python 环境的Lib文件夹下新建fcntl.py文件,在其中写入下面的内容:

    fcntl.py是linux平台上python自带的包,windows平台下没有,所以需要自己设计一份,让windows下引用fcntl功能的程序可以跑通。

    参考资料:https://blog.csdn.net/jacke121/article/details/82218151

    LOCK_UN=8
    LOCK_EX=2
    F_GETFD=1
    FD_CLOEXEC=1
    F_SETFD=2
    
    def fcntl(fd, op, arg=0):
        return 0
    
    
    def ioctl(fd, op, arg=0, mutable_flag=True):
        if mutable_flag:
            return 0
        else:
            return ""
    
    
    def flock(fd, op):
        return
    
    
    def lockf(fd, operation, length=0, start=0, whence=0):
        return
    

    在这里插入图片描述
    注意:这些*号的地方,点击后可以跳转到fcntl.pyi文件,里面写有函数类型、参数类型的注解。

    什么是.pyi文件 https://blog.csdn.net/weixin_40908748/article/details/106252884

    注意:运行中缺什么参数定义可以去linux中的python里面导入fcntl包去查,然后再copy回来就行。
    在这里插入图片描述

    https://blog.csdn.net/dandanforgetlove/article/details/108337188

    一个不太想关的博客,感觉以后有可能会用到,先留个连接

    import mlogging,No module named ffi,import fcntl 报错
    https://blog.csdn.net/AlanGuoo/article/details/84309886

    测试代码:

    import threading
    import time
    import datetime
    import fcntl
    
    def run(n):
        print(f"task {n}:{datetime.datetime.now()}")
        with open('./threading.txt','a',encoding='utf-8') as fj:
            fcntl.flock(fj,fcntl.LOCK_EX)
            fj.write(f"task {n}:{datetime.datetime.now()}")
            fcntl.flock(fj,fcntl.LOCK_UN)
    
    if __name__ == '__main__':
        t1=threading.Thread(target=run,args=(1,))
        t2=threading.Thread(target=run,args=(2,))
        t3=threading.Thread(target=run,args=(3,))
        t4=threading.Thread(target=run,args=(4,))
        t1.start()
        t2.start()
        t3.start()
        t4.start()
    
        pass
    
    展开全文
  • 文件锁,锁文件

    2017-12-01 20:31:42
    锁文件,可设置不同用户使用不同的权限,锁文件,可设置不同用户使用不同的权限
  • 小何讲Linux: 文件锁及其实例

    千次阅读 2017-12-04 15:30:07
    1. 文件锁基本概念 Linux中软件、硬件资源都...文件锁是用于解决资源的共享使用的一种机制:当多个用户需要共享一个文件时,Linux通常采用的方法是给文件上锁,来避免共享的资源产生竞争的状态。 文件锁包括建议
    转载地址:http://blog.csdn.net/rl529014/article/details/51336161

    1.  文件锁基本概念

    Linux中软件、硬件资源都是文件(一切皆文件),文件在多用户环境中是可共享的。

    文件锁是用于解决资源的共享使用的一种机制:当多个用户需要共享一个文件时,Linux通常采用的方法是给文件上锁,来避免共享的资源产生竞争的状态

    文件锁包括建议性锁和强制性锁:

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


    在Linux中,实现文件上锁的函数有lockf()和fcntl()

    • lockf()用于对文件施加建议性锁

    • fcntl()不仅可以施加建议性锁,还可以施加强制锁。

    • fcntl()还能对文件的某一记录上锁,也就是记录锁。

    • 记录锁又可分为读取锁和写入锁,其中读取锁又称为共享锁,它能够使多个进程都能在文件的同一部分建立读取锁。

    • 写入锁又称为排斥锁,在任何时刻只能有一个进程在文件的某个部分建立写入锁。

    • 在文件的同一部分不能同时建立读取锁和写入。

    2.  fcntl()函数格式
              fcntl是一个非常通用的函数,它可以对已打开的文件进行各种操作,包括管理文件锁、获得和设置文件描述符标志、获得和设置文件状态标志、文件描述符的复制等很多功能,
    所需头文件
    #include <sys/types.h>
    #include <unistd.h>
    #include <fcntl.h>
    函数原型:int fcntl(int fd,int cmd,...);
    int fcntl(int fd,int cmd,long arg);
    int fcntl(int fd, int cmd, struct flock *lock)
    函数传入值fd:被参数cmd操作的文件描述符


    函数原型
    int fcntl(int fd,int cmd,long arg);
    int fcnt1(int fd, int cmd, struct flock *lock)
    函数传入值cmd
    F_DUPFD:复制一个现存的描述符
    F_GETFD:获得fd的close-on-exec(执行时关闭)文件描述符标志,若标志未设置,则文件经过exec()函数之后仍保持打开状态
    F_SETFD:设置close-on-exec 标志,该标志由参数arg 的FD_CLOEXEC位决定
    F_GETFL:得到open设置的标志
    F_SETFL :改变open设置的标志
    F_GETLK:根据lock参数值,决定是否可以上文件锁
    F_SETLK:设置lock参数值的文件锁


    关于close_on_exec
    close_on_exec 是一个进程所有文件描述符(文件句柄)的位图标志,每个比特位代表一个打开的文件描述符,用于确定在调用系统调用execve()时需要关闭的文件句柄(参见include/fcntl.h)。当一个程序使用fork()函数创建了一个子进程时,通常会在该子进程中调用execve()函数加载执行另一个新程序。此时子进程将完全被新程序替换掉,并在子进程中开始执行新程序。若一个文件描述符在close_on_exec中的对应比特位被设置,那么在执行execve()时该描述符将被关闭,否则该描述符将始终处于打开状态。

    函数传入值cmd
    F_SETLKW:这是F_SETLK的阻塞版本(命令名中的W表示等待(wait))。在无法加锁时,会进入睡眠状态;如果可以加锁或者捕捉到信号则会返回
    lock:是一个指向flock结构的指针,设置记录锁的具体状态
    函数返回值
    成功时,返回值依赖于第二个参数cmd
    -1:出错





    cmd取值方式
    F_GETLK, F_SETLK或F_SETLKW:      获得/设置记录锁的功能,成功则返回0,若有错误则返回-1,错误原因存于errno。
    F_GETLK :  测试由lock所描述的锁是否能使用。如果存在一把锁,它阻止创建由lock所描述的锁,则将这把现存锁的信息写到lock指向的结构中(l_type-已有锁的类型,l_pid-加锁的进程号)。如果不存在这种情况,则除了将l_type设置为F_UNLCK之外,lock所指向的结构中的其他信息保持不变。

    F_SETLK : 按照第三个参数lock指向的flock结构体所描述的锁的信息设置或者清除一个文件的锁。


    F_SETLK: 被用来实现共享(或读)锁(F_RDLCK)或独占(写)锁(F_WRLCK),同样可以去掉这两种锁(F_UNLCK)。如果共享锁或独占锁不能被设置,fcntl()将立即返回EAGAIN   


    3.  fcntl()使用实例

    在该下面的实例中,首先给flock结构体的对应字段赋予相应的值。
    接着使用两次fcntl()函数,分别用于判断文件是否可以上锁和给相关文件上锁,这里用到的cmd值分别为F_GETLK和F_SETLK(或F_SETLKW)。
    用 F_GETLK 命令判断是否可以进行flock 结构所描述的锁操作:
    若可以加锁,则flock结构的l_type会被设置为F_UNLCK,其他域不变;
    否则,则l_pid被设置为拥有文件锁的进程号,l_type被设置为已有锁的类型,其他域不变。


    • 文件记录所功能源代码如下(文件保存为 mylock.c):
    1. /* 文件保存为 mylock.c */  
    2.   
    3. int lock_set(int fd,int type)  
    4. {  
    5.     struct flock old_lock,lock;  
    6.     lock.l_whence = SEEK_SET;  
    7.     lock.l_start = 0;  
    8.     lock.l_len = 0;  
    9.     lock.l_type = type;  
    10.     lock.l_pid = -1;  
    11.           
    12.     fcntl(fd,F_GETLK,&lock);  
    13.   
    14.     if(lock.l_type != F_UNLCK)  
    15.     {  
    16.           
    17.         if (lock.l_type == F_RDLCK)    
    18.         {  
    19.             printf("Read lock already set by %d\n",lock.l_pid);  
    20.         }  
    21.         else if (lock.l_type == F_WRLCK)   
    22.         {  
    23.             printf("Write lock already set by %d\n",lock.l_pid);  
    24.         }                         
    25.     }  
    26.       
    27.     lock.l_type = type;  
    28.       
    29.     if ((fcntl(fd,F_SETLKW,&lock)) < 0)  
    30.     {  
    31.         printf("Lock failed : type = %d\n",lock.l_type);  
    32.         return 1;  
    33.     }  
    34.       
    35.     switch (lock.l_type)  
    36.     {  
    37.         case F_RDLCK:  
    38.         {  
    39.             printf("Read lock set by %d\n",getpid());  
    40.         }  
    41.         break;  
    42.         case F_WRLCK:  
    43.         {  
    44.             printf("write lock set by %d\n",getpid());  
    45.         }  
    46.         break;  
    47.         case F_UNLCK:  
    48.         {  
    49.             printf("Release lock by %d\n",getpid());  
    50.             return 1;  
    51.         }  
    52.         break;  
    53.           
    54.         default:  
    55.         break;  
    56.   
    57.     }  
    58.     return 0;  
    59. }  

    • 下面的实例是文件写入锁的测试用例,文件名为,wirte_lock.c 。
      这里首先创建了一个hello 文件,之后对其上写入锁,最后释放写入锁,代码如下所示:
    1. #include<stdio.h>  
    2. #include <unistd.h>  
    3. #include <sys/file.h>  
    4. #include <sys/types.h>  
    5. #include <sys/stat.h>  
    6. #include <stdlib.h>  
    7. #include "mylock.c"  
    8. int main(void)  
    9. {    
    10.     int fd;/* 首先打开文件*/  
    11.     fd = open("hello",O_RDWR | O_CREAT, 0644);if(fd < 0)  
    12.     {         
    13.         printf("Open file error\n");      
    14.         exit(1);     
    15.     }      
    16.     lock_set(fd, F_WRLCK);      /* 给文件上写入锁*/    
    17.     getchar();             /*程序暂停,按回车键继续*/      
    18.     lock_set(fd, F_UNLCK);  /* 给文件解锁*/     
    19.     getchar();     
    20.     close(fd);     
    21.     exit(0);      
    22.     return 0;  
    23. }  


    运行截图如下:



    在PC机上测试:
    开启两个终端,并且在两个终端上同时运行该程序,以达到多个进程操作一个文件的效果。
    首先在终端1运行,然后在终端2上运行,注意终端二中的第一行输出。




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


    接下来的程序是文件读取锁的测试用例,原理和上面的程序一样。文件名为read_lock.c。

    1. #include <unistd.h>  
    2. #include <sys/file.h>  
    3. #include <sys/types.h>  
    4. #include <sys/stat.h>  
    5. #include <stdio.h>  
    6. #include <stdlib.h>  
    7. #include "mylock.c"  
    8. int main(void)  
    9. {  
    10.     int fd;fd = open("hello",O_RDWR | O_CREAT, 0644);if(fd < 0)  
    11.     {     
    12.         printf("Open file error\n");  
    13.         exit(1);    
    14.     }  
    15.     lock_set(fd, F_RDLCK);  /* 给文件上读取锁*/  
    16.     getchar();  
    17.     lock_set(fd, F_UNLCK);  /* 给文件解锁*/  
    18.     getchar();  
    19.     close(fd);  
    20.     exit(0);      
    21.     return 0;  
    22. }  

    运行结果如下:



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


    观察可知,读锁是共享锁。

    展开全文
  • linux 文件锁

    2021-02-17 21:20:13
    1. 文件锁基本概念 Linux中软件、硬件资源都是文件(一切皆文件),文件在多用户环境中是可共享的。 文件锁是用于解决资源的共享使用的一种机制:当多个用户需要共享一个文件时,Linux通常采用的方法是给文件上锁,...
  • 文件锁的使用浅析

    万次阅读 多人点赞 2018-04-22 22:27:23
    概述 ...文件锁(也叫记录锁)的作用是,当一个进程读写文件的某部分时,其他进程就无法修改同一文件区域。 能够实现文件锁的函数主要有2个:flock和fcntl。 早期的伯克利版本只支持flock,该...
  • Linux文件---文件锁

    千次阅读 2017-09-02 17:03:12
    通过之前的open()/close()/read()/write()/...当某进程在更新文件内数据时,期望某种机制能防止多个进程同时更新文件从而导致数据丢失,或者防止文件内容在未更新完毕时被读取并引发后续问题,这种机制就是“文件锁”。
  • Linux文件锁

    千次阅读 2018-06-28 20:23:01
    一、文件锁的分类: 翻阅参考资料,你会发现文件锁可以进行很多的分类,最常见的主要有读锁与写锁,前者也叫共享锁,后者也叫排斥锁,值得注意的是,多个读锁之间是不会相互干扰的,多个进程可以在同一时刻对同一个...
  • Linux下C/C++给文件加锁

    千次阅读 2019-12-21 23:14:16
    一 为何需要文件锁 假设有一个菜谱文件,其内容是今天需要买的菜,现在有2个进程A和B,要去访问这个文件,它们的操作如下, A读取了这个文件内容 B读取了这个文件内容 A对读出的内容做了一些修改,添加了番茄,然后...
  • 文件锁和记录锁

    千次阅读 2018-07-13 10:21:55
    http://blog.chinaunix.net/uid-23634108-id-2393492.html 下面介绍两种两种Linux下对文件加锁的两种方式一、文件锁思想:假设有一个文件A。创建一个加锁文件B,通过不同的进程互斥的访问此加锁文件B达到互斥的访问...
  • c#文件锁的实现

    千次阅读 2018-06-02 21:41:58
    大致功能是,启动 文件锁 程序后,将想要上锁的文件或文件夹拖入到加密区,实现对 文件或文件夹 的加密,或者点击浏览文件夹 选择自己想要加密的文件或文件夹。1&gt;效果: 2&gt;对文件或文件夹上锁的原理...
  • 文件锁

    万次阅读 2016-05-26 18:27:01
    文件锁定是多用户、多任务操作系统中一个非常重要的组成部分。程序经常需要共享数据,而这通常是通过文件 来实现的。因此,对于这些程序来说,建立某种控制文件的方式就非常重要了。只有这样,文件才可以通过一种...
  • linux 文件锁-进程间同步

    千次阅读 2018-03-08 18:07:08
    一、场景 多进程间同步除了信号量、共享内存(原子操作)同步外,还可以使用文件锁来实现。二、实现 linux中有两种是方式,分别是flock()函数和fcntl()函数。使用效果大致相同 flock函数: fd:文件描述符 ...
  • linux文件锁

    千次阅读 2014-11-20 11:06:43
    第一节Unix支持的文件锁技术介绍 Unix系统允许多个进程同时对一个文件进行读写,虽然每一个read或write调用本身是原子的,但内核在两个读写操作之间并没有加以同步,因此当一个进程多次调用read来读文件时,其它...
  • 进程同步--------文件锁的使用

    千次阅读 2020-01-27 04:38:42
    文件锁:只能在进程同步使用...F_SETLK(struct flock*) 设置文件锁(trylock)//非阻塞 F_SETLKW(strcut flock *)设置文件锁(lock)//阻塞 F_GETLK(struct flock *)获取文件锁 参数3:struct flock{ short l_type;...
  • 文件锁的本质核心和原理

    万次阅读 2018-06-05 09:27:47
    其中说明了flock 是与打开文件文件表项相关联的。根据《Unix 环境高级编程》对打开文件的介绍,打开的文件在进程表和操作系统中的对应的结构如下图所示:每个进程在进程表中都一个对应的项目,叫做进程表项,上图...
  • 在shell中实现文件锁的两种方式2.使用flock命令 1.在shell中实现文件锁的两种方式 方法一:利用普通文件 (1)在脚本启动时检查特定文件是否存在,如果存在,则等待一段时间后继续检查,直到文件不存时创建该文件...
  • Linux flock文件锁详解

    千次阅读 2020-11-25 23:30:34
    -h --help Display this text #显示帮助 -V --version Display version #显示版本 flock文件锁的使用 1.创建sh文件 vim test.sh #! /bin/bash echo "Hello World" sleep 10 2.创建锁文件 touch test.lock #随便命名 ...
  • 电脑怎么设置软件

    千次阅读 2021-07-04 05:23:30
    右键图标,选择属性在跳出的对话框选择安全,再选择编辑把除了管理员(administrator)的用户全部删掉,然后应用确定之后注销用户,重新登录电脑选择新建的那个用户,就打不开设置权限的软件了步...
  • NodeJS保证文件读取一致性的办法有两种,一是读取文件设置隔离标志,隔离标志是指,当使用fs模块打开文件时,在打开模式中,添加一个x标记。例如下面的代码将以独占的方式去读写一个文件:fs.open('config.loc', '...
  • UOS 加锁文件夹/文件之解锁

    千次阅读 2022-03-02 14:47:50
    UOS 系统文件管理
  • 文件锁及其实例

    千次阅读 2018-04-13 10:04:04
    1. 文件锁基本概念Linux中软件、硬件资源都是文件(一切皆文件),文件在多用户环境中是可共享的。文件锁是用于解决资源的共享使用的一种机制:当多个用户需要共享一个文件时,Linux通常采用的方法是给文件上锁,来...
  • JAVA 文件锁 FileLock

    千次阅读 2017-12-04 11:54:59
    概述 FileLock是java 1.4 版本后出现的一个类,它可以通过对一个可写文件(w)加锁,保证同时只有...也可以看出,能够利用文件锁的这种性质,在一些场景下,虽然我们不需要操作某个文件, 但也可以通过 FileLock 来进行
  • Linux C:文件锁flock

    千次阅读 2017-01-20 14:08:04
     在多线程开发中,互斥可以用于对临界资源的保护,防止数据的不一致,这是最为普遍的使用方法。那在多进程中如何处理文件之间的同步呢?我们看看下面的图: 图中所示的是两个进程在无同步的情况下同时更新...
  • 多用户多任务操作系统中非常重要的一个内容就是文件锁。用户在更新文件时,期望可以使用某种机制,防止两种进程同时更新文件同一区域而造成丢失,或者防止文件内容在未更新完毕时被读取等并发引起的问题,这种机制...
  • NFS中的文件锁

    万次阅读 2013-03-09 15:26:16
    文件锁是保持文件同步的一种手段,当多个用户同时操作同一个文件时,文件锁可以保证数据不发生冲突。NFSv2和NFSv3依靠NLM协议实现文件锁,NFSv4本身实现了文件锁,不需要NLM协同工作了。NFS中的文件锁既可以加在...
  • 多进程文件锁

    千次阅读 2014-12-17 10:21:09
    一、多进程文件锁 当多个用户共同使用、操作一个文件的情况下,这时,Linux通常采用的方法是给文件上锁,来避免共享的资源产生竞争的状态 1.文件锁方式 对当前读写文件进行加锁处理,简单说下两种加锁方式: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 394,700
精华内容 157,880
关键字:

如何设置文件锁