文件锁

最新推荐文章于 2023-09-10 15:54:48 发布
最新推荐文章于 2023-09-10 15:54:48 发布
阅读量1.2w 收藏 2
点赞数 1
分类专栏： Linux编程 文章标签： Linux c语言 文件锁 数据 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanbo622/article/details/51509573
版权

      文件锁定是多用户、多任务操作系统中一个非常重要的组成部分。程序经常需要共享数据，而这通常是通过文件

来实现的。因此，对于这些程序来说，建立某种控制文件的方式就非常重要了。只有这样，文件才可以通过一种安全

的方式更新，或者说，当一个程序正在对文件进行写操作时，文件就会进入一个暂时状态在这个状态下，如果另外

一个程序尝试读这个文件，它就会自动停下来等待这个状态的结束。

      Linux提供了多种特性来实现文件锁。其中最简单的方法就是以原子操作方式创建锁文件，所谓"原子操作"就是

在创建锁文件时，系统将不允许其他的事情发生。这就给程序提供了一种方式来确保它所创建是文件是唯一的，而且

这个文件不可能被其它程序在同一时刻创建。

第二种方法更高级一些，它允许程序锁定文件的一部分，从而可以独享对这一部分内容的访问。有这两种不同的方式

可以实现第二种形式的文件锁定。我们将只对其中的一种做详细介绍，因为两种方式非常相似——第二种方式不过是

程序接口稍微不同而已。

一、这些锁文件通常都被放置在一个特定位置，并带有一个与控制资源相关的文件名。例如，当一个调制解调器正在

被使用时，Linux通常会在/var/spool目录下创建一个锁文件。

注意：锁文件仅仅只是充当一个指示器的角色，程序间需要通过相互协作来使用它们。

二、区域锁定

      用创建锁文件的方法来控制对诸如串行口或者不经常访问的文件之类的资源的独占式访问，是一个不错的选择，

但它并不适用于访问大型的共享文件。假设你有一个大文件，它有一个程序写入数据，但却有许多不同的程序同时

对这个文件进行更新。当一个程序负责记录长期以来连续收集到的数据，而其他一些程序将一直不停地运行，所以

它们需要一些协调方法来提供对一个文件的并发访问。可以通过锁定文件区域的方法来解决这个问题，文件中的某

个特定部分被锁定了，但是其他程序可以访问这个文件中的其它部分。这被称为文件段锁定或文件区域锁定。Linux

提供了至少两种方式来实现这一功能：它们使用不同的底层实现，因此决不要混合使用这两种类型的调用，而应坚

持使用其中的一种。

三、文件锁功能函数

      int fcntl(int fileds, int command, struct flock *flock_structure);

      fcntl对一个打开的文件描述符进行操作，并根据command参数的设置完成不同的任务。

      command参数：F_GETLK、F_SETLK、F_SETLKW；

      flock结构体：short l_type、short l_whence、off_t l_shart、off_t l_len、pid_t l_pid。

      1、F_GETLK：用于获取files(第一个参数)打开的文件的锁信息。它不会尝试去锁定文件。调用进程把自己想创

          建的锁类型信息传递给fcntl，使用F_GETLK命令的fcntl就会返回将会阻止获取锁的任何信息。

          short l_type：如果是共享(只读)锁则取值为F_RDLCK，如果是独占(写)锁则取值为F_WRLCK

          short l_whence：SEEK_SET、SEEK_CUR、SEEK_END中的一个

          off_t l_shart：感兴趣的文件区域的第一个字节的相对位置

          off_t l_len：感兴趣的文件区域的字节数

          pid_t l_pid：持有锁的进程的标识符

               进程可能使用F_GETLK调用来查看文件中某个区域的当前锁状态。它应该设置flock结构体来表明它需要

          的锁类型，并定义它感兴趣的文件区域。fcntl调用如果成功就返回非-1的值。如果文件已被锁定从而阻止锁

          请求成功执行，fcntl会用相关信息覆盖flock结构。如果锁请求可以成功执行，flock结构将保持不变。如果

          F_GETLK调用无法获得信息，它将返回-1表明失败。如果F_GETLK调用成功，调用程序就必须检查flock结

         构的内容来判断其是否被修改过。因为l_pid的值被设置成持有锁的进程(若有的话)的标识符，多以通过检查这

         个字段就可以很方便地判断出flock结构是否被修改过。

      2、F_SETLK:对files指向的文件的某个区域加锁或解锁。flock结构中使用的值(与F_GETLK命令中用到的不同之

         处)如下：

         l_type：如果是只读或共享锁则取值为F_RDLCK，如果是独占或写锁则取值为F_WRLCK，如果是解锁则取值

                      为F_UNLK

         l_pid：不使用

              与F_GETLK一样，要加锁的区域由flock结构中的l_start、l_whence和l_en的值定义。如果加锁成功，fcntl

         将返回一个非-1的值；如果失败，则返回-1.这个函数总是立刻返回。

      3、F_SETLKW:与介绍的F_SETLK作用相同，但在无法获取锁时，这个调用将等待直到可以为止。一旦这个调用

          开始等待，只有在可以获取锁或收到一个信号时它才会返回。

      程序对某个文件拥有的所有锁都将在响应的文件描述符被关闭时自动清除。在程序结束时也会自动清除各种锁。

四、锁定状态下的读写操作

      当对文件区域加锁之后，必须使用底层的read和write调用来访问文件中的数据，而不要使用更高级的fread和

fwrite调用，这是因为fread和fwrite会对读写的数据进行缓存，所以执行一次fread调用来读取文件中的头100个字节可

能(事实上，是几乎肯定如此)会读取超过100个字节的数据，并将多余的数据在函数库中进行缓存。如果程序再次使

用fread来读取下100个字节的数据，它实际上将读取已缓存在函数库中的数据，而不会引发一个底层的read调用来从

文件中读取更多的数据。

      例1：测试文件上的锁 

              lock.c -->lock

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

const char *test_file="test_lock";
int main(int argc, char *argv[])
{
	int file_desc;
	int byte_count;
	char *byte_to_write="A";
	struct flock region_1;
	struct flock region_2;
	int res;
	file_desc=open(test_file,O_RDWR|O_CREAT,0666);
	if(!file_desc)
	{
		fprintf(stderr,"Unable to open %s for read/write\n",test_file);
		exit(EXIT_FAILURE);
	}
	for(byte_count=0;byte_count<100;byte_count++)
	{
		write(file_desc,byte_to_write,1);
	}
	//把文件的10~30字节设为区域1，并在其上设置共享锁
	region_1.l_type=F_RDLCK;
	region_1.l_whence=SEEK_SET;
	region_1.l_start=10;
	region_1.l_len=20;
	//把文件的40~50字节设为区域2，并在其上设置独占锁
	region_2.l_type=F_WRLCK;
	region_2.l_whence=SEEK_SET;
	region_2.l_start=40;
	region_2.l_len=10;
	//锁定文件
	printf("Process %d locking file\n",getpid());
	res=fcntl(file_desc,F_SETLK,&region_1);
	if(res==-1)fprintf(stderr,"Failed to lock region_1\n");
	res=fcntl(file_desc,F_SETLK,&region_2);
	if(res==-1)fprintf(stderr,"Failed to lock region_2\n");

	sleep(60);
	printf("Process %d closing file\n",getpid());
	close(file_desc);
	exit(EXIT_SUCCESS);
	
	return 0;
}

 

              lock2.c -->lock2

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

const char *test_file="test_lock";
#define SIZE_TO_TRY 5

void show_lock_info(struct flock *to_show);
int main(int argc, char *argv[])
{
	int file_desc;
	int res;
	struct flock region_to_test;
	int start_byte;

	file_desc=open(test_file,O_RDWR|O_CREAT,0666);
	if(!file_desc)
	{
		fprintf(stderr,"Unable to open %s for read/write",test_file);
		exit(EXIT_FAILURE);
	}
	for(start_byte=0;start_byte<99;start_byte+=SIZE_TO_TRY)
	{
		//设置希望测试的文件区域
		region_to_test.l_type=F_WRLCK;
		region_to_test.l_whence=SEEK_SET;
		region_to_test.l_start=start_byte;
		region_to_test.l_len=SIZE_TO_TRY;
		region_to_test.l_pid=-1;

		printf("Testing F_WRLCK on region from %d to %d\n",start_byte,start_byte+SIZE_TO_TRY);
		//测试文件上的锁
		res=fcntl(file_desc,F_GETLK,&region_to_test);
		if(res==-1)
		{
			fprintf(stderr,"F_GETLK failed\n");
			exit(EXIT_FAILURE);
		}
		if(region_to_test.l_pid!=-1)
		{
			printf("Lock would fail. F_GETLK returned:\n");
			show_lock_info(&region_to_test);	
		}
		else
		{
			printf("F_WRLCK - Lock would succed\n");
		}
		//用共享(读)锁重复测试一次，再次设置希望测试的文件区域
		region_to_test.l_type=F_RDLCK;
		region_to_test.l_whence=SEEK_SET;
		region_to_test.l_start=start_byte;
		region_to_test.l_len=SIZE_TO_TRY;
		region_to_test.l_pid=-1;
		printf("Testing F_RDLCK on region from %d to %d\n",start_byte,start_byte+SIZE_TO_TRY);
		//再次测试文件上的锁
		res=fcntl(file_desc,F_GETLK,&region_to_test);
		if(res==-1)
		{
			fprintf(stderr,"F_GETLK faild\n");
			exit(EXIT_FAILURE);
		}
		if(region_to_test.l_pid!=-1)
		{
			printf("Lock would fail. F_GETLK returned:\n");
			show_lock_info(&region_to_test);
		}
		else
		{
			printf("F_RDLCK - Lock would succeed\n");
		}
	}
	close(file_desc);
	return 0;
}
void show_lock_info(struct flock *to_show)
{
	printf("\t l_type %d, ",to_show->l_type);
	printf("l_whence %d, ",to_show->l_whence);
	printf("l_start %d, ",(int)to_show->l_start);
	printf("l_len %d, ",(int)to_show->l_len);
	printf("l_pid %d\n",to_show->l_pid);
}


       为了测试首先运行./lock &(后台运行)，然后运行./lock2

       下面为输出内容：

 

Testing F_WRLCK on region from 0 to 5
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 0 to 5
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 5 to 10
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 5 to 10
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 10 to 15
Lock would fail. F_GETLK returned:
	 l_type 0, l_whence 0, l_start 10, l_len 20, l_pid 6448
Testing F_RDLCK on region from 10 to 15
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 15 to 20
Lock would fail. F_GETLK returned:
	 l_type 0, l_whence 0, l_start 10, l_len 20, l_pid 6448
Testing F_RDLCK on region from 15 to 20
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 20 to 25
Lock would fail. F_GETLK returned:
	 l_type 0, l_whence 0, l_start 10, l_len 20, l_pid 6448
Testing F_RDLCK on region from 20 to 25
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 25 to 30
Lock would fail. F_GETLK returned:
	 l_type 0, l_whence 0, l_start 10, l_len 20, l_pid 6448
Testing F_RDLCK on region from 25 to 30
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 30 to 35
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 30 to 35
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 35 to 40
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 35 to 40
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 40 to 45
Lock would fail. F_GETLK returned:
	 l_type 1, l_whence 0, l_start 40, l_len 10, l_pid 6448
Testing F_RDLCK on region from 40 to 45
Lock would fail. F_GETLK returned:
	 l_type 1, l_whence 0, l_start 40, l_len 10, l_pid 6448
Testing F_WRLCK on region from 45 to 50
Lock would fail. F_GETLK returned:
	 l_type 1, l_whence 0, l_start 40, l_len 10, l_pid 6448
Testing F_RDLCK on region from 45 to 50
Lock would fail. F_GETLK returned:
	 l_type 1, l_whence 0, l_start 40, l_len 10, l_pid 6448
Testing F_WRLCK on region from 50 to 55
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 50 to 55
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 55 to 60
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 55 to 60
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 60 to 65
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 60 to 65
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 65 to 70
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 65 to 70
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 70 to 75
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 70 to 75
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 75 to 80
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 75 to 80
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 80 to 85
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 80 to 85
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 85 to 90
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 85 to 90
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 90 to 95
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 90 to 95
F_RDLCK - Lock would succeed
Testing F_WRLCK on region from 95 to 100
F_WRLCK - Lock would succed
Testing F_RDLCK on region from 95 to 100
F_RDLCK - Lock would succeed


 解析：

       lock2程序把文件中的每5个字节分成一组，为每个组设置一个区域结构来测试锁，然后通过使用这些结构来

判断对应区域是否可以被加写锁或读锁。返回信息将显示造成锁请求失败的区域字节数和从字节0开始的偏移量。

因为返回结构中的l_pid元素包含当前拥有文件锁的程序的进程标识符，所以程序先把它设置为-1(一个无效值)，然后

在fcntl调用返回后检测其值是否被修改过。如果该区域当前未被锁定，l_pid的值就不会被改变。

      为了理解程序的输出含义，需要查看程序中包含的头文件fcntl.h(通常是/usr/include/fcntl.h)，l_type的值为1对应

的定义为F_WRLCK：表明锁失败的原因是已经存在一个写锁了，l_type的值为0对应的定义为F_RDLCK：已经存在

一个读锁了。在文件中未被lock2程序锁定的区域上，无论是共享锁还是独占锁都将会成功。

      可以看到10~30字节上可以设置一个共享锁，因为程序lock2在该区域上设置的是共享锁而不是独占锁。而在

40~50字节的区域上，两种锁都将失败，因为lock2已经在该区域上设置了一个独占锁(F_WRLCK)。

      例2：文件锁的竞争
             lock.c -->lock  与上诉代码相同


             lock3.c -->lock3

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

const char *test_file="test_lock";

int main(int argc, char *argv[])
{
	int file_desc;
	int res;
	struct flock region_to_lock;

	file_desc=open(test_file,O_RDWR|O_CREAT,0666);
	if(!file_desc)
	{
		fprintf(stderr,"Unable to open %s for read/write",test_file);
		exit(EXIT_FAILURE);
	}
	//程序的其余部分指定文件的不同区域，并尝试在它们之上执行不同的锁操作
	region_to_lock.l_type=F_RDLCK;
	region_to_lock.l_whence=SEEK_SET;
	region_to_lock.l_start=10;
	region_to_lock.l_len=5;

	printf("Process %d,trying F_RDLCK, region %d to %d\n",getpid(),(int)region_to_lock.l_start,(int)(region_to_lock.l_start+region_to_lock.l_len));
	res=fcntl(file_desc,F_SETLK,&region_to_lock);
	if(res==-1)
	{
		printf("Process %d - faild to lock region\n",getpid());
	}
	else
	{
		printf("Process %d - obtained to lock region\n",getpid());
	}

	region_to_lock.l_type=F_UNLCK;
	region_to_lock.l_whence=SEEK_SET;
	region_to_lock.l_start=10;
	region_to_lock.l_len=5;

	printf("Process %d,trying F_UNLCK, region %d to %d\n",getpid(),(int)region_to_lock.l_start,(int)(region_to_lock.l_start+region_to_lock.l_len));
	res=fcntl(file_desc,F_SETLK,&region_to_lock);
	if(res==-1)
	{
		printf("Process %d - faild to lock region\n",getpid());
	}
	else
	{
		printf("Process %d - unlocked region\n",getpid());
	}

	region_to_lock.l_type=F_UNLCK;
	region_to_lock.l_whence=SEEK_SET;
	region_to_lock.l_start=0;
	region_to_lock.l_len=50;

	printf("Process %d,trying F_UNLCK, region %d to %d\n",getpid(),(int)region_to_lock.l_start,(int)(region_to_lock.l_start+region_to_lock.l_len));
	res=fcntl(file_desc,F_SETLK,&region_to_lock);
	if(res==-1)
	{
		printf("Process %d - faild to lock region\n",getpid());
	}
	else
	{
		printf("Process %d - unlocked region\n",getpid());
	}

	region_to_lock.l_type=F_WRLCK;
	region_to_lock.l_whence=SEEK_SET;
	region_to_lock.l_start=16;
	region_to_lock.l_len=5;

	printf("Process %d,trying F_WRLCK, region %d to %d\n",getpid(),(int)region_to_lock.l_start,(int)(region_to_lock.l_start+region_to_lock.l_len));
	res=fcntl(file_desc,F_SETLK,&region_to_lock);
	if(res==-1)
	{
		printf("Process %d - faild to lock region\n",getpid());
	}
	else
	{
		printf("Process %d - obtained lock on region\n",getpid());
	}
	
	region_to_lock.l_type=F_RDLCK;
	region_to_lock.l_whence=SEEK_SET;
	region_to_lock.l_start=40;
	region_to_lock.l_len=10;

	printf("Process %d,trying F_RDLCK, region %d to %d\n",getpid(),(int)region_to_lock.l_start,(int)(region_to_lock.l_start+region_to_lock.l_len));
	res=fcntl(file_desc,F_SETLK,&region_to_lock);
	if(res==-1)
	{
		printf("Process %d - faild to lock region\n",getpid());
	}
	else
	{
		printf("Process %d - obtained lock on region\n",getpid());
	}

	region_to_lock.l_type=F_WRLCK;
	region_to_lock.l_whence=SEEK_SET;
	region_to_lock.l_start=16;
	region_to_lock.l_len=5;

	printf("Process %d,trying F_WRLCK, region %d to %d\n",getpid(),(int)region_to_lock.l_start,(int)(region_to_lock.l_start+region_to_lock.l_len));
	res=fcntl(file_desc,F_SETLKW,&region_to_lock);
	if(res==-1)
	{
		printf("Process %d - faild to lock region\n",getpid());
	}
	else
	{
		printf("Process %d - obtained lock on region\n",getpid());
	}

	printf("Process %d ending\n",getpid());
	close(file_desc);
	exit(EXIT_SUCCESS);
	return 0;
}


       为了测试首先运行./lock &(后台运行)，然后运行./lock3

      下面为输出内容：
 

Process 26333,trying F_RDLCK, region 10 to 15
Process 26333 - obtained to lock region
Process 26333,trying F_UNLCK, region 10 to 15
Process 26333 - unlocked region
Process 26333,trying F_UNLCK, region 0 to 50
Process 26333 - unlocked region
Process 26333,trying F_WRLCK, region 16 to 21
Process 26333 - faild to lock region
Process 26333,trying F_RDLCK, region 40 to 50
Process 26333 - faild to lock region
Process 26333,trying F_WRLCK, region 16 to 21

Process 26323 closing file
Process 26333 - obtained lock on region
Process 26333 ending


解析：

      首先，这个程序尝试试用共享锁来锁定文件中10~15字节的区域。这块区域已被一个共享锁锁定，但共享锁允许

同时使用，因此加锁成功。然后解除它自己对这块区域的共享锁，这也成功了。接下来，这个程序视图解除这个文件

前50字节上的锁，虽然它实际上未对这块区域进行锁定，但也成功了，因为虽然这个程序并未对这个区域加锁，但

解锁请求最终的结果取决于这个程序在文件的头50个字节上并没有设置任何锁。

      这个程序接下来视图用一把独占锁来锁定文件中16~21字节的区域。由于这个区域上已有了一把共享锁，独占锁

无法创建，因此这个锁定操作失败了。然后，程序又尝试试用一把共享锁来锁定文件中40~59字节的区域。由于这个

区域上已经有了一把独占锁，因此这个锁定操作也失败了。最后，程序再次尝试在文件中16~21字节的区域上获得一

把独占锁，但这次它用F_SETLKW命令来等待直到它可以获得一把锁为止。于是程序的输出就会遇到一个很长的停

顿，直到已锁住这块区域的lock程序因为完成sleep调用、关闭文件而释放了它先前获得的所有锁为止。lock3程序继

续执行，成功锁定了这块区域，最后它也退出了运行。

 

韩搏
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言文件锁
qq_35527370的博客
09-03 1067
F_SETLKW :设置文件锁。函数功能： 设置文件锁。fd ： 文件描述符。
文件加锁
ycnian
03-10 2725
1.客户端处理程序     这篇文章中我们讲讲文件锁的加锁过程，首先说说与文件锁相关的数据结构 struct nfs4_lock_state { // nfs4_state结构中包含多个nfs4_lock_state结构，这些结构构成了一个链表， // ls_locks指向链表中相邻的元素. struct list_head l
linux shell之文件锁
01-10
经常在 shell 脚本里要阻止其它进程，比如 msmtp 自带的mail queue 脚本，这个脚本的互斥做法是不正确的，下面介绍下发现的三个通过文件达到互斥的正确做法。 1. util-linux 的 flock 这个命令有两种用法：  flock LOCKFILE COMMAND  ( flock -s 200; COMMAND; ) 200>LOCKFILEflock 需要保持打开锁文件，对于第二种使用方式并不方便，而且 -s 方式指定文件句柄可能冲突。好处是不需要显式的解锁，进程退出后锁必然释放。 2. liblockfile1 的 dotlockfile 号称最灵活可靠的文件锁实现
F_GETLK与F_SETLK的使用
业9
04-10 6437
关键词：l_type fcntl（）函数调用成功，返回0。 F_GETLK申请锁，成功返回l_type=F_UNLCK；否则，返回原值。 F_SETLK加锁或解锁，成功返回l_type为预置值。 共享（读）锁与独占（写）锁在单进程中可互相取代，多进程不兼容。 多进程，原锁为读锁时，在同文件域可设读锁；原锁为写锁，在同文件域不可设读/写锁。#include<unistd.h> #includ
106-记录锁（测试命令）
进击的小学生
03-20 947
有的时候，你并不想直接了当的对某个文件的部分内容先请求锁，只是想提前知道能不能对其加锁，然后再决定做其它的事情。1. 测试锁的方法可以将 fcntl 的 cmd 命令设置为 F_GETLK。下面这段程序演示了对文件内容进行测试加写锁。使用 F_GETLK 命令，返回的结果保存在 l_type 字段和 l_pid 字段。int testlock(int fd, int start, int len)
fcntl函数详解-文件锁
qq_41082118的博客
01-31 4325
文件锁也被称为记录所，文件锁如果深讲的话，内容不少（比如文件锁最起码分为了建议锁和强制性锁，暂时挖坑，后面填）。 文件锁作用 顾名思义，就是用来保护文件数据的。当多个进程共享读写同一个文件时，为了不让进程们各自读写数据时相互干扰，我们可以使用进程信号量来互斥实现，除了可以使用进程信号量以外，还可以使用我们本小节要讲的“文件锁”来实现，而且功能更丰富，使用起来相对还更容易些。 多进程读写文件 ...
【Linux高级 I/O（7）】初识文件锁——fcntl()方法及其独占性、共享性实验（附全文代码）
cj_lsk的博客
05-26 1845
如果一个进程对文件的某个区域已经上了一把锁，后来该进程又试图在该区域再加一把锁，那么通常新加的锁将替换旧的锁。如果两个区域出现了重叠，譬如 100~200 字节区间和 150~250 字节区间，150~200 就是它们的重叠部分，一个进程对同一文件的相同区域不可能同时加两把锁，新加的锁会把旧的锁替换掉，譬如先对 100~200 字节区间加写锁、再对 150~250 字节区间加读锁，那么 150~200 字节区间最终是读锁控制的，关于这个问题，大家可以自己去验证、测试。只有当请求的锁可用时，进程才会被唤醒。
文件解锁
ycnian
03-10 2467
文件解锁是加锁的反操作，当处理完毕后应该尽量赶快解锁，避免影响其他用户访问文件。NFS中与文件解锁相关的操作有两个：LOCKU和RELEASE_LOCKOWNER。LOCKU的作用是解锁，RELEASE_LOCKOWNER的作用是释放stateid。 LOCKU客户端程序     客户端处理LOCKU请求的函数是nfs4_proc_unlck()，这个函数最终调用了nfs4_do_un
shell脚本实现文件锁功能
09-15
本文将深入探讨如何使用Shell脚本来实现文件锁功能，特别是排它锁，以防止脚本重复执行，确保数据安全和程序的正确性。 文件锁是多进程环境下控制资源访问的一种机制。在Linux系统中，当多个进程可能同时尝试修改同...
文件锁，锁文件
12-01
锁文件，可设置不同用户使用不同的权限，锁文件，可设置不同用户使用不同的权限
PHP flock 文件锁详细介绍
10-27
脚本之家小编今天将为大家详解关于php中文件锁函数flock函数用法简介，希望通过本文的介绍大家对于Linux方面能够更加的了解
免费文件锁
11-23
免费版文件锁，为你的文档加水印。需要使用时再解水印，可以单独存在U盘中，运行会被报危险程序，无毒放心使用。
Qt加锁操作、文件锁、生产消费锁GUI演示
06-20
在本文中，我们将深入探讨如何在Qt环境中使用线程锁，包括文件锁和生产者-消费者锁，并结合Visual Studio 2019进行GUI编程。这些知识点对于理解多线程同步以及Qt GUI应用的开发至关重要。 首先，让我们从Qt中的线程...
Linux 文件锁 - fcntl
cpp_learner的博客
02-11 1724
fcntl 文件锁的常用用法
fcntl函数讲解
weixin_43743711的博客
02-01 7372
前言 fcntl系统调用可以用来对已打开的文件描述符进行各种控制操作以改变已打开文件的的各种属性 函数原型： #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); int fcntl(int fd, int cmd, ... /* arg
[C++] 使用flock构建文件锁，进程读写锁
CoderUnion的博客
09-10 1123
C语言文件锁函数flock以及利用其构建一个简单的进程互斥锁
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
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值