Read-write lock is a commonly used synchronization mechanism, which allows multiple processes or threads to perform concurrent read operations or mutually exclusive write operations on the same resource, thereby improving the efficiency and security of the system. In Linux system programming, there are many ways to implement read-write locks, such as using the pthread library, using file locks, etc. This article will introduce you to a method of using the fcntl() system call to implement read-write locks, as well as its principles, usage, advantages and disadvantages, so that you can better use and understand this technique in Linux system programming.
When multiple processes read and write access to the same file, in order to ensure the integrity of the data, the file needs to be locked. Files can be locked and unlocked through the fcntl() function.
1.1. Function description: Manipulate file characteristics based on file descriptors.
1.2. Usage:
int fcntl(int fd, int cmd);
int fcntl(int fd, int cmd, long arg);
int fcntl(int fd, int cmd, struct flock *lock);
fd: File descriptor.
cmd: Operation command.
arg: Parameters used by the command. Whether the arg parameter is required depends on the cmd command.
lock: lock information.
Create two new files, the source code is shown in 2.1 and 2.2 below.
2.1. Add read lock to the file
#include
\#include
\#include
\#include
\#include
int main(int argc, const char * argv [ ])
{
int fd = open("test.c", O_RDONLY);
if (fd == -1)
{
perror("open failed:");
return -1;
}
struct stat sta;
fstat(fd,&sta);
struct flock lock;
lock.l_len = sta.st_size;
lock.l_pid = getpid();
lock.l_start = 0;
lock.l_type = F_RDLCK;
lock.l_whence = SEEK_SET;
printf("进程pid: %d\n",lock.l_pid);
if(fcntl(fd,F_SETLK,&lock) == -1)
{
perror("fcntl fail ");
return -1;
}
else
{
printf("add read lock success!\n");
}
sleep(10);
close(fd);
return 0;
}
2.2.给文件加写锁
\#include
\#include
\#include
\#include
\#include
int main(int argc, const char * argv [ ])
{
int fd = open("test.c", O_WRONLY);
if (fd == -1)
{
perror("open failed:");
return -1;
}
struct stat sta;
fstat(fd,&sta);
struct flock lock;
lock.l_len = sta.st_size;
lock.l_pid = getpid();
lock.l_start = 0;
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
printf("进程pid: %d\n",lock.l_pid);
while(fcntl(fd,F_SETLK,&lock) == -1 )
{
perror("fcntl:");
sleep(1);
struct flock lock_1;
lock_1 = lock;
lock_1.l_type = F_WRLCK; //
fcntl(fd,F_GETLK,&lock_1);//获取文件锁状态，及加锁（lock_1.l_type）能否成功
switch(lock_1.l_type)
{
case F_RDLCK:
printf("检测到读锁 pid = %d \n",lock_1.l_pid);
break;
case F_WRLCK:
printf("检测到写锁 pid = %d \n",lock_1.l_pid);
break;
case F_UNLCK:
printf("检测到已解锁.pid = %d \n",lock_1.l_pid);
}
}
printf("写锁设置成功\n");
getchar();
close(fd);
return 0;
}
/*
Notice:
1. Lock_1 in fcntl(fd,F_GETLK,&lock_1) must be initialized, and lock_1.l_type must be set to the corresponding lock to determine whether the lock can be successful and the reason for the failure.
2. When GETLK, fcntl first detects whether there is a lock that can prevent this locking. If there is, it overwrites the information of the flock structure (lock_1). If not, set the type of lock_1.l_type to F_UNLCK.
*/
For write locks (F_WRLCK exclusive locks), only one process can enjoy an exclusive lock on any specific area of the file.
For read locks (F_RDLCK shared locks), many different processes can hold shared locks on the same area on the file at the same time. In order to hold a shared lock, the file must be opened for reading or read/write. As long as any process owns a shared lock, no other process can obtain an exclusive lock.
Compile and execute separately:
liu@ubuntu:~/learn/lrn_linux$ ./readlock.out 进程pid: 16458 add read lock success! liu@ubuntu:~/learn/lrn_linux$ ./writelock.out 进程pid: 16459 fcntl:: Resource temporarily unavailable 检测到读锁 pid = 16458 fcntl:: Resource temporarily unavailable 检测到读锁 pid = 16458 fcntl:: Resource temporarily unavailable 检测到读锁 pid = 16458 fcntl:: Resource temporarily unavailable 检测到读锁 pid = 16458 fcntl:: Resource temporarily unavailable 检测到读锁 pid = 16458 fcntl:: Resource temporarily unavailable 检测到读锁 pid = 16458 fcntl:: Resource temporarily unavailable 检测到读锁 pid = 16458 fcntl:: Resource temporarily unavailable 检测到已解锁.pid = 16459
Write lock set successfully
It can be seen that when the file is occupied by a read lock, a write lock (exclusive lock) cannot be added
liu@ubuntu:~/learn/lrn_linux$ ./writelock.out
Process pid: 16349
Write lock set successfully
liu@ubuntu:~/learn/lrn_linux$ ./readlock.out
Process pid: 16350
fcntl fail : Resource temporarily unavailable
So, the locking is successful.
Through this article, you should have a basic understanding of the method of using fcntl() to implement read-write locks in Linux system programming, and know its principles, usage, advantages and disadvantages. You should also understand the purpose and impact of using fcntl() to implement read-write locks, and how to correctly use and configure fcntl() in Linux system programming. We recommend that you use fcntl() to achieve your goals in scenarios where you need to implement read-write locks. At the same time, we also remind you to pay attention to some potential issues and challenges when using fcntl(), such as compatibility, portability, performance, etc. I hope this article can help you better use Linux system programming and let you master the skills and advantages of fcntl() under Linux.
The above is the detailed content of A technique for Linux system programming: using fcntl() to implement read-write locks. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
