Linux(编程)：多进程同步-文件锁
文件锁又叫记录锁，他的作用是：当一个进程正在读或修改文件的某个部分是，可以通过文件锁阻止其他进程修改同一文件区。
不仅仅是文件，对于多进程间共享的资源，都可以通过文件锁进行同步。
文件锁所使用的接口函数为：
int fcntl(int fd, int cmd, struct flock *lock);
/*其中cmd的可选值为：
cmd = F_GETLK，测试是否可以加锁，返回值仅对当前有效，无法保证后续的加锁或解锁一定成功
cmd = F_SETLK，设置锁(加锁或解锁)，如果无法设置锁，该函数会立即返回一个EACCESS或EAGAIN错误，而不会阻塞
cmd = F_SETLKW， 阻塞设置一把锁，无法设置锁的时候，会阻塞直到该锁能够进行设置
*/以下是对文件锁进行的封装：
//file_lock.h
#ifndef FILE_LOCK_H
#define FILE_LOCK_H
#include
#include
#include
#include
#include
using std::string;
enum class FILE_LOCK_RES{
OK = 0,
FILE_OPEN_FAILED = 1,
READ_LOCK_FAILED = 2,
WRITE_LOCK_FAILED = 3,
UNLOCK_FAILED = 4,
CHECK_LOCK_FAILED = 5,
CHECK_LOCK_READY = 6,
CHECK_LOCK_BUSY = 7,
};
class FileLock{
public:
FileLock(const string& filePath);
FILE_LOCK_RES readLock();
FILE_LOCK_RES writeLock();
FILE_LOCK_RES unlock();
FILE_LOCK_RES checkReadLock(pid_t* pidinfo = nullptr);
FILE_LOCK_RES checkWriteLock(pid_t* pidinfo = nullptr);
~FileLock();
private:
int m_fd;
string m_filePath;
void initFlock(struct flock& lock, short type, short whence, off_t start, off_t len);
string getPrefix();
};
#endif
//file_lock.cpp
#include
#include
#include
#include
#include "file_lock.h"
using namespace std;
FileLock::FileLock(const string& filePath):m_filePath(filePath)
{
m_fd = open(m_filePath.c_str(), O_RDWR | O_CREAT, S_IRWXU | S_IRWXG | S_IRWXO);
if(m_fd < 0)
{
cout<<"file:"< 0)
{
close(m_fd);
m_fd = -1;
}
}
void FileLock::initFlock(struct flock& lock, short type, short whence, off_t start, off_t len)
{
lock.l_type = type;
lock.l_whence = whence;
lock.l_start = start;
lock.l_len = len;
}
FILE_LOCK_RES FileLock::readLock()
{
if(m_fd < 0)
{
return FILE_LOCK_RES::FILE_OPEN_FAILED;
}
struct flock lock;
initFlock(lock, F_RDLCK, SEEK_SET, 0, 0);
if(fcntl(m_fd, F_SETLKW, &lock) != 0)
{
cout< //main.cpp
#include
#include
#include
#include
#include "file_lock.h"
using namespace std;
int main()
{
FileLock fl("./test_file_lock");
fl.writeLock();
fl.readLock();
fl.unlock();
fl.readLock();
fl.unlock();
return 0;
} //CMakeLists.txt
cmake_minimum_required(VERSION 3.5)
project(file_lock)
add_executable(file_lock main.cpp file_lock.cpp)
target_include_directories(file_lock PRIVATE ${CMAKE_SOURCE_DIR})编译运行程序输出：
1678107928 pid:6427 file:./test_file_lock write lock ok
1678107928 pid:6427 file:./test_file_lock read lock ok
1678107928 pid:6427 file:./test_file_lock unlock ok
1678107928 pid:6427 file:./test_file_lock read lock ok
1678107928 pid:6427 file:./test_file_lock unlock ok
可以看出，同一个进程可以同时对文件已加锁区间进行多次加锁。
通过上面封装的类对以下几种具体的情况加以验证和说明：
加锁的进程结束后会自动释放锁
#include
#include
#include
#include
#include "file_lock.h"
using namespace std;
string getPrefix()
{
time_t time_now = time(NULL);
pid_t pid = getpid();
string prefix = to_string((unsigned long)time_now) + " pid:" + to_string((unsigned long)pid) + " ";
return prefix;
}
int main()
{
pid_t pid = fork();
if(pid == 0)
{//child
cout< 0)
{//father
cout< 运行程序输出：
1678109358 pid:6583 father pid is 6583
1678109358 pid:6584 child pid is 6584
1678109358 pid:6584 file:./test_file_lock write lock ok
1678109360 pid:6583 file:./test_file_lock write lock ok
1678109360 pid:6583 file:./test_file_lock unlock ok
1678109362 pid:6583 child pid:6584 exit
close文件描述符，加载在其上的锁也会自动释放：
#include
#include
#include
#include
#include "file_lock.h"
using namespace std;
string getPrefix()
{
time_t time_now = time(NULL);
pid_t pid = getpid();
string prefix = to_string((unsigned long)time_now) + " pid:" + to_string((unsigned long)pid) + " ";
return prefix;
}
void testFl()
{
FileLock fl("./test_file_lock");
fl.writeLock();
}
int main()
{
pid_t pid = fork();
if(pid == 0)
{//child
cout< 0)
{//father
cout< 运行程序输出：
1678109603 pid:6613 father pid is 6613
1678109603 pid:6614 child pid is 6614
1678109603 pid:6614 file:./test_file_lock write lock ok
1678109604 pid:6613 file:./test_file_lock write lock ok
1678109604 pid:6613 file:./test_file_lock unlock ok
1678109608 pid:6614 child exit
1678109608 pid:6613 wait child pid:6614 exit
fork出的子进程不能继承父进程的锁：
#include
#include
#include
#include
#include "file_lock.h"
using namespace std;
string getPrefix()
{
time_t time_now = time(NULL);
pid_t pid = getpid();
string prefix = to_string((unsigned long)time_now) + " pid:" + to_string((unsigned long)pid) + " ";
return prefix;
}
int main()
{
cout< 0)
{//father
sleep(2);
fl.unlock();
waitpid(pid, 0, 0);
cout< 运行程序输出：
1678109969 pid:6669 father pid is 6669
1678109969 pid:6669 file:./test_file_lock write lock ok
1678109969 pid:6670 child pid is 6670
1678109971 pid:6669 file:./test_file_lock unlock ok
1678109971 pid:6670 file:./test_file_lock write lock ok
1678109976 pid:6670 file:./test_file_lock unlock ok
1678109976 pid:6670 child exit
1678109976 pid:6669 wait child pid:6670 exit
文件锁的状态可以进行检查：
#include
#include
#include
#include
#include "file_lock.h"
using namespace std;
string getPrefix()
{
time_t time_now = time(NULL);
pid_t pid = getpid();
string prefix = to_string((unsigned long)time_now) + " pid:" + to_string((unsigned long)pid) + " ";
return prefix;
}
int main()
{
pid_t pid = fork();
if(pid == 0)
{//child
cout< 0)
{//father
cout< 运行程序输出：
1678110443 pid:6741 father pid is 6741
1678110443 pid:6741 file:./test_file_lock write lock ok
1678110443 pid:6742 child pid is 6742
1678110444 pid:6742 file:./test_file_lockread lock is busy by pid:6741
1678110444 pid:6742 lock is busy
1678110445 pid:6741 file:./test_file_lock unlock ok
1678110449 pid:6742 file:./test_file_lockread lock is ready
1678110449 pid:6742 lock is ready
1678110449 pid:6742 file:./test_file_lock write lock ok
1678110449 pid:6742 file:./test_file_lock unlock ok
1678110449 pid:6742 child exit
1678110449 pid:6741 wait child pid:6742 exit
另外需要注意的是：加锁时，进程必须对文件有相应的文件访问权限，即加读锁，该文件必须是读打开，加写锁时，该文件必须是写打开。另外一个进程如果已经加了锁，那么不能通过F_GETLK用于测试自己是否能继续加锁，因为同一个进程可以对文件的同一个区域多次加锁。