结构体flock的指针
:
struct flcok {
short int l_type; /* 锁定的状态*/
//这三个参数用于分段对文件加锁,若对整个文件加锁,则:l_whence=SEEK_SET,l_start=0,l_len=0;
short int l_whence;/*决定l_start位置*/
off_t l_start; /*锁定区域的开头位置*/
off_t l_len; /*锁定区域的大小*/
pid_t l_pid; /*锁定动作的进程*/
};
l_type 有三种状态:
F_RDLCK 建立一个供读取用的锁定
F_WRLCK 建立一个供写入用的锁定
F_UNLCK 删除之前建立的锁定
int fcntl(int fd, int cmd, struct flock *lock);
int cmd
//F_SETLKW对加锁操作进行阻塞,
//F_SETLK不对加锁操作进行阻塞,立即返回
当使用F_SETLK宏,不进行阻塞加锁操作时。两个进程有对文件加锁失败的情况出现。
当使用F_SETLKW宏,进行阻塞加锁操作时。两个进程没有文件加锁失败的情况。但是根据进程的输出日志,可以明显看出A进程对文件操作时,B进程停止对文件操作。
测试过程中打开文件使用O_RDWR | O_CREAT | O_APPEND模式,并对文件加写锁。锁对打开文件没有影响,但是对另一进程加锁和写操作有影响。
加锁对同一进程中的多线程无效。同一进程中的多线程对同一文件加锁,后加锁的线程会覆盖前一个线程加的文件锁。
fcntl文档中写到,一个进程对一个文件的区域只能加一个类型的锁
实现代码如下:
//filelock.h
#ifndef __FILE_LOCK_HPP__
#define __FILE_LOCK_HPP__
#ifdef __cplusplus
extern "C" {
#endif
int file_lock(int fd);
int file_unlock(int fd);
#ifdef __cplusplus
}
#endif
#endif //__FILE_LOCK_HPP__
------------------------华丽分割线-----------------------------
//filelock.cpp
#include
#include
#include "filelock.h";
int file_lock(int fd){
struct flock s_flock;
s_flock.l_type = F_WRLCK;
s_flock.l_whence = SEEK_SET;
s_flock.l_start = 0;
s_flock.l_len = 0;
s_flock.l_pid = getpid();
//F_SETLKW对加锁操作进行阻塞,
//F_SETLK不对加锁操作进行阻塞,立即返回
return fcntl(fd, F_SETLKW, &s_flock);
}
int file_unlock(int fd){
return fcntl(fd, F_SETLKW, F_UNLCK);
}
---------------------------------华丽的分割线--------------------------
test.cpp
#include "filelock.h"
#include
#include
#include
#include
#include
#include
#include
#include
int main(int argc,char *argv[]) {
int pid = -1;
int i = 5;
while(i--){
if ((pid = fork()) < 0) { //fork出错
puts("fork1 error");
} else if (pid > 0) {//父进程
sleep(5);
if (waitpid(pid, NULL, 0) < 0)
puts("waitpid error");
} else {//子进程
sleep(1);
int li_file = 0;
int li_lck_st = -1;
li_file = open("tt.txt", O_WRONLY|O_CREAT, 0777);
if( li_file < 0 ) {
printf("file open error\n");
}
printf("li_file=[%d] pid=[%d]\n", li_file , getpid() );
li_lck_st = file_lock(li_file);
sleep(5);
printf("li_lck_st=%d pid =%d\n", li_lck_st, getpid() );
file_unlock(li_file);
close(li_file);
printf("close file pid=%d unlock\n", getpid());
return 0;
}
}
return 0;
}
------------------------------华丽分割线---------------------------
//makefile
#########################################################
#Project: test
#By: Khan.Lau
#Description: test
#########################################################
CC = gcc
CXX = g++
STRIP = strip
AR = ar
PROJ = $(shell pwd)
DLLPATH = $(shell find $(PROJ) -name *.so*)
LIBPATH = /usr
INCS = -I$(LIBPATH)/include \
-I$(PROJ)/src/inc \
-I$(PROJ)/src
CXXINCS = -I$(LIBPATH)/include \
-I$(LIBPATH)/include/c++/4.3 \
-I$(LIBPATH)/include/c++/4.3/backward \
-I$(PROJ)/src/inc \
-I$(PROJ)/src
CFLAGS = -g -Wall $(CXXINCS)
#
CONFIGURATION = release
#
BIN = test.exe
#LIB = lib/HuaWeiBsc.a
#包路径
LIBS = -L$(PROJ)/lib \
-L$(LIBPATH)/lib -lz
SRCS = $(wildcard \
src/lib/*.cpp \
src/kernel/*.cpp)
OBJBINS = $(SRCS:.cpp=.o)
.c.o:
$(CC) -o $@ -c $< $(CFLAGS)
.cpp.o:
$(CXX) -o $@ -c $< $(CFLAGS)
COLORH=echo -en "\033[1;32;40m"
COLORN=echo -en "\033[m"
all : $(BIN)
$(BIN) : $(OBJBINS)
$(CXX) -o $(CONFIGURATION)/$(BIN) $(OBJBINS) $(LIBS)
@$(COLORN)
$(shell echo "$(BIN) build complete.")
#$(LIB) : $(OBJBINS)
# ar rc $(LIB) $(OBJBINS)
clean :
rm -f $(OBJBINS)
rm -f $(BIN)
-----------------------------华丽分割线--------------------------
测试环境 ubuntu 8.10, redhat 7.3, redhat fc3 redhat enterprise 4.6
结果:
khan@khan-laptop:~/project/filelock/release$ ./test.exe
li_file=[3] pid=[10959]
li_lck_st=0 pid =10959
close file pid=10959 unlock
li_file=[3] pid=[10961]
li_lck_st=0 pid =10961
close file pid=10961 unlock
li_file=[3] pid=[10964]
li_lck_st=0 pid =10964
close file pid=10964 unlock
li_file=[3] pid=[10966]
li_lck_st=0 pid =10966
close file pid=10966 unlock
li_file=[3] pid=[10969]
li_lck_st=0 pid =10969
close file pid=10969 unlock
posted on 2008-12-24 10:45 Khan 阅读(7770) 评论(3) 编辑 收藏 引用 所属分类: GCC/G++ 、跨平台开发
评论
# re: Linux 进程互斥锁
2008-12-24 17:32
lymons
虽然没有仔细看你写的代码,但从设计思路上也能看出一些端倪出来。
flock实现的文件锁实际上是一个建议锁。也就是意味着在这个锁很容易
收到外界的干扰。如果用于锁定的文件被某人/某进程删除了,那使用
这个文件锁的程序就很容易出现紊乱。这点也需要考虑。
从你man出来的信息来看
LinuxThreads currently does not support process-shared semaphores, thus sem_init always returns with error ENOSYS if pshared is not zero.
这说的应该指的是LinuxThread吧,指的不是进程。
sema设计的初衷就是为了让进程间进行通信,信号量如果不能共享那也就不能进行通信是吧。所以,我认为你应该放心的去用sema。至少是目前版本的大多数的linux系统都没有问题。这仅仅是俺一家之言,如有不对之处请斧正。 回复 更多评论
# re: Linux 进程互斥锁
2008-12-24 17:50
Khan.Lau
我这里没有使用flock 直接使用了fcntl, 貌似flock也是用fcntl来实现的.
我猜测 LinuxThreads currently does not support process-shared semaphores, thus sem_init always returns with error ENOSYS if pshared is not zero.这句可能说LinuxThreads 这部分负责实现semaphores, 但是当前的版本没有实现进程间共享信号灯的部分,
实际我在我系统里面测试, 确实是没有返回ENOSYS, 但是sem_wait在semaphore大于0的情况下这里根本就没有阻塞
回复 更多评论
# re: Linux 进程互斥锁
2008-12-25 10:43
lymons
flock就是用fcntl系统调用实现的。
因为在linux内核里fcntl就是按照advise模式来实现,所以他一直是一个建议锁。
我建议你可以使用sys v的信号量,在Linux下这毕竟比posix的更常用一些。
如,使用semget(2)来创建信号量,利用semop(2)来做PV操作。 回复 更多评论