Linux记录锁（文件锁）

记录锁(record locking)的功能是：

当第一个进程正在读或修改文件的某个部分时，使用记录锁可以阻止其他进程修改同一文件区。

“记录”这个词是一种误用，因为UNIX系统内核根本没有使用文件记录这种概念。

一个更适合的术语可能是字节范围锁 (byte-range locking)，因为它锁定的只是文件中的一个区域(也可能是整个文件)。

struct flock {
             short l_type; /* 锁类型： F_RDLCK, F_WRLCK, F_UNLCK */
             short l_whence; /* 取值为SEEK_SET(文件头), SEEK_CUR(文件当前位置), SEEK_END(文件尾) */
             off_t l_start; /* 相对于l_whence字段的偏移量 */
             off_t l_len; /* 需要锁定的长度 */
             pid_t l_pid; /* 当前获得文件锁的进程标识（F_GETLK） */
};

实例代码：

#include <stdio.h>
#include <pthread.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <syslog.h>
#include <string.h>
//对文件进行上锁
#define read_lock(fd, offset, whence, len) \
	lock_reg((fd), F_SETLK, F_RDLCK, (offset), (whence), (len))
#define readw_lock(fd, offset, whence, len) \
	lock_reg((fd), F_SETLKW, F_RDLCK, (offset), (whence), (len))
#define write_lock(fd, offset, whence, len) \
	lock_reg((fd), F_SETLK, F_WRLCK, (offset), (whence), (len))
#define writew_lock(fd, offset, whence, len) \
	lock_reg((fd), F_SETLKW, F_WRLCK, (offset), (whence), (len))
#define un_lock(fd, offset, whence, len) \
	lock_reg((fd), F_SETLK, F_UNLCK, (offset), (whence), (len))
//判断文件能不能锁
#define is_read_lockable(fd, offset, whence, len) \
	lock_test((fd), F_RDLCK, (offset), (whence), (len))
#define is_write_lockable(fd, offset, whence, len) \
	lock_test((fd), F_WRLCK, (offset), (whence), (len)) 

int
lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len)
{
	struct flock lock;
	int a = 852;
	lock.l_type = type; /* F_RDLCK, F_WRLCK, F_UNLCK */
	lock.l_start = offset; /* byte offset, relative to l_whence */
	lock.l_whence = whence; /* SEEK_SET, SEEK_CUR, SEEK_END */
	lock.l_len = len; /* #bytes (0 means to EOF) */
	lock.l_pid = getpid();
	//printf("%d \n", lock.l_pid);	
	return(fcntl(fd, cmd, &lock));   
}
pid_t
lock_test(int fd, int type, off_t offset, int whence, off_t len)
{
	struct flock lock1;
	int a;
	lock1.l_type = type; /* F_RDLCK or F_WRLCK */
	lock1.l_start = offset; /* byte offset, relative to l_whence */
	lock1.l_whence = whence; /* SEEK_SET, SEEK_CUR, SEEK_END */
	lock1.l_len = len; /* #bytes (0 means to EOF) */
	lock1.l_pid = getpid();

	if (fcntl(fd, F_GETLK, &lock1) < 0)
		perror("fcntl error");
	if (lock1.l_type == F_UNLCK)
	{				
		return(0); /* false, region isn’t locked by another proc */
	}
		
	return(lock1.l_pid); /* true, return pid of lock owner */
}
int
main(void)
{
	int i = -1;
	int j = -1;
	int fd = -1;
	int pid = -1;
	char buf[30] = {"this is  second\n"};
	
	if ( (fd = open("myfile", O_RDWR) ) < 0)
	{
		perror("open");
		exit(-1);
	}
	
	j = is_write_lockable(fd, 5, SEEK_SET, 1);  //判断有没有锁
	if( j == 0 )
	{
		printf("thid file have no lock \n");
		printf("Now ,using file lock \n");
		write_lock(fd, 5, SEEK_SET, 1);  //上锁
		for(;;);  //endless loop
	}else
	{
		printf("pid = %d using file lock\n", j);	//output using file lock Processes ID
	}
	exit(0);			
}

结果：

终端1：

# ./a.out 
thid file have no lock 
Now ,using file lock 

终端2：

# ps -au | grep a.out 
root       9942  103  0.0   4200   352 pts/1    R+   09:25   0:13 ./a.out
# ./a.out
pid = 9942 using file lock