我有一个项目,包括多个进程,可以读取或写入到一个单一的数据库。我希望使用系统调用flock/open/close来实现由锁文件同步的单写/多读者锁定。使用羊群,打开和关闭文件来实现许多读卡器单写入锁
一旦发生锁定失败,任何重新尝试再次锁定锁定的操作都将由请求锁定的较高级别进行(与自旋锁定不同)。
不幸的是,在测试这个模型时,它在解锁之前未被锁定的情况下失败。 也许你可以帮我找到我干了什么错在这里做的事:
// keep read and write file descriptors as global variables.
// assuming no more than 1 thread can access db on each process.
int write_descriptor=0;
int read_descriptor=0;
int lock_write() {
if((write_descriptor = open(LOCKFILE, O_RDWR|O_CREAT,0644))<0) {
return LOCK_FAIL;
}
if(flock(write_descriptor, LOCK_EX)<0) {
close(write_descriptor);
write_descriptor = 0;
return LOCK_FAIL;
}
return LOCK_SUCCESS;
}
int unlock_write() {
if(!write_descriptor) {
// sanity: try to unlock before lock.
return LOCK_FAIL;
}
if(flock(write_descriptor,LOCK_UN)<0) {
// doing nothing because even if unlock failed, we
// will close the fd anyway to release all locks.
}
close(write_descriptor);
write_descriptor = 0;
return LOCK_SUCCESS;
}
int lock_read() {
if((read_descriptor = open(LOCKFILE,O_RDONLY))<0) {
return LOCK_FAIL;
}
if(flock(read_descriptor, LOCK_SH)<0) {
close(read_descriptor);
return LOCK_FAIL;
}
return LOCK_SUCCESS;
}
int unlock_read() {
if(!read_descriptor) {
// sanity : try to unlock before locking first.
return LOCK_FAIL;
}
if(flock(read_descriptor, LOCK_UN)<0) {
// doing nothing because even if unlock failed, we
// will close the fd anyway to release all locks.
}
close(read_descriptor);
read_descriptor = 0;
return LOCK_SUCCESS;
}
int read_db() {
if(lock_read() != LOCK_SUCCESS) {
return DB_FAIL;
}
// read from db
if(unlock_read() != LOCK_SUCCESS) {
// close fd also unlock - so we can fail here (can i assume that ?)
}
}
int write_db() {
if(lock_write() != LOCK_SUCCESS) {
return DB_FAIL;
}
//write to db.
if(unlock_write() != LOCK_SUCCESS) {
// close fd also unlock - so we can fail here (can i assume that ?)
}
}
这个过程是多线程的吗?如果是这样,这将不起作用,因为文件锁由进程拥有,而不是线程。 –
@DavidSchwartz,嗨。正如我在问题中提到的,我假设每个进程只有一个线程处理锁(这就是为什么我可以使用全局变量。 – Zohar81
你能更准确地知道它是如何失败的吗?(另外,为什么这个标签'multithreading'?) –