linux 文件锁

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

假设有一个 account.dat 文件，用于存储帐户余额，其初始值为200。并发系统有两个进程来更新这个文件上的余额值：

进程 A : 读取当前值，减去 20，然后将结果保存回文件中。
进程 B : 读取当前值，加 80，然后将结果写回到文件中。

显然，在顺序执行完这两个进程后，我们期望文件具有以下值：200-20 + 80 = 260。
但是，如果进程的执行不是按预期的顺序执行，在以下这种情况下，可能会出现不一样的结果：

进程 A : 读取文件的当前值 200 ，并准备进行进一步的计算。
进程 B : 读取相同的文件并获得当前余额 200 。
进程 A : 计算 200-20 并将结果 180 保存回文件。
进程 B : 不知道余额已更新。因此，它仍将使用过时的值 200 计算 200 + 80，并将结果 280 写入文件。

结果，account.dat 文件中保存的余额就是 280 而不是预期值 260。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

假设文件 account.dat 仍然包含初始值 200。

备注：必须了解的是，协同锁不是由操作系统或文件系统设置的。因此即使进程 A 锁定了文件，进程 B 仍然可以通过系统调用自由地读取、写入甚至删除文件。如果进程 B 执行文件操作而不尝试获取锁，我们说进程 B 不与进程 A 合作。

协同锁是如何为协作进程工作的：
- 进程 A ：获取 account.dat 文件的排他锁，然后打开并读取该文件以获取当前值：200。
- 进程 B ：在读取文件之前尝试获取 account.dat 文件的锁（与进程 A 合作）。由于进程 A 已锁定文件，进程 B 必须等待进程 A 释放锁定。
- 进程 A ：计算 200-20 并将 180 写回文件。
- 进程 A ：释放锁。
- 进程 B ：现在获取锁并读取文件，并获得更新后的值：180。
- 进程 B ：启动其逻辑并将结果 260 (180+80) 写回文件。
- 进程 B ：释放锁，以便其他协作进程可以读取和写入文件。

后面可以看看使用 flock 命令实现。

1
2
3
4
5
6
7
8

[root@c7u3test1 ~]# lslocks 
COMMAND           PID  TYPE SIZE MODE  M START END PATH
lvmetad           463 POSIX   4B WRITE 0     0   0 /run/lvmetad.pid
crond             628 FLOCK   4B WRITE 0     0   0 /run/crond.pid
atd               629 POSIX   4B WRITE 0     0   0 /run/atd.pid
abrtd             606 POSIX   4B WRITE 0     0   0 /run/abrt/abrtd.pid
master           1512 FLOCK  33B WRITE 0     0   0 /var/spool/postfix/pid/master.pid
master           1512 FLOCK  33B WRITE 0     0   0 /var/lib/postfix/master.lock

1
2
3
4
5
6
7

[root@c7u3test1 ~]# cat /proc/locks 
1: FLOCK  ADVISORY  WRITE 1512 fd:00:34534423 0 EOF
2: FLOCK  ADVISORY  WRITE 1512 fd:00:1284 0 EOF
3: POSIX  ADVISORY  WRITE 606 00:12:15127 0 EOF
4: POSIX  ADVISORY  WRITE 629 00:12:15111 0 EOF
5: FLOCK  ADVISORY  WRITE 628 00:12:15087 0 EOF
6: POSIX  ADVISORY  WRITE 463 00:12:12033 0 EOF

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

1:  FLOCK  ADVISORY  WRITE 1512 fd:00:34534423  0  EOF
-1- --2--  ---3---   --4-- --5- -------6------ -7- -8-

# 1: 第一个字段是序列号
# 2: 第二个字段表示使用的锁的类，例如 FLOCK（来自flock 系统调用）或POSIX（来自lockf、fcntl 系统调用）
# 3: 第三个字段表示锁定类型，它可以有两个值：ADVISORY 或 MANDATORY
# 4: 第四个字段显示锁是写锁还是读锁
# 5: 第五个字段表示持有锁的进程的ID
# 6: 第六个字段包含一个冒号分隔值字符串，以 major-device:minor-device:inode 的格式显示锁定文件的 id
# 7和8: 第七和第八字段一起显示被锁定文件的锁定区域的开始和结束;在此示例行中，整个文件被锁定

1

$ flock FILE_TO_LOCK COMMAND

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#!/bin/bash
file="balance.dat"
value=$(cat $file)
echo "Read current balance: $value"

# sleep 10 seconds to simulate business calculation
progress=10
while [[ $progress -lt 101 ]]; do
	echo -n -e "\033[77DCalculating new balance.. $progress%"
	sleep 1
	progress=$((10+progress))
done
echo ""

value=$((value+$1))
echo "Write new balance ($value) back to $file." 
echo $value > "$file"
echo "Done."

1
2
3
4
5
6

#!/bin/bash
#-----------------------------------------
# process A: lock the file and subtract 20 
# from the current balance
#-----------------------------------------
flock --verbose account.dat ./update_balance.sh '-20'

1
2
3
4
5
6
7

$ ./a.sh 
flock: getting lock took 0.000002 seconds
flock: executing ./update_balance.sh
Read current balance:100
Calculating new balance..100%
Write new balance (80) back to balance.dat.
Done.

1
2

$ lslocks | grep 'balance'
flock      825712  FLOCK   4B WRITE 0      0      0 /tmp/test/balance.dat

1
2
3
4
5
6

#!/bin/bash
#----------------------------------------
# process B: add 80 to the current balance in a
# non-cooperative way
#----------------------------------------
./update_balance.sh '80'

1
2
3
4
5
6

#!/bin/bash
#----------------------------------------
# process B: add 80 to the current balance
# in a cooperative way
#----------------------------------------
flock --verbose balance.dat ./update_balance.sh '80'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

## 命令格式
flock [options] file|directory command [arguments]
flock [options] file|directory -c command
flock [options] number

## 几个参数的说明
-c，--command command：后接命令
-x，-e,--exclusive number： 获得排他锁，有时称为写锁。默认的锁
-n，--nb,--nonblock： 如果无法立即获得锁，则失败而不是等待。有关使用的退出代码，请参见 -E 选项
-E，--conflict-exit-code： 使用 -n 选项时使用的退出代码。默认值为 1
-o，--close： 在执行命令之前关闭持有锁的文件描述符。如果命令生成不应持有锁的子进程会比较有用
-s，--shared：获得共享锁，有时称为读锁
-u，--unlock： 释放锁。这通常不是必需的，因为当文件关闭时锁会自动删除;但在特殊情况下可能需要，例如如果封闭的命令组可能已经派生了一个不应该的后台进程保留了锁
-w，--wait，--timeout seconds：如果在几秒钟内无法获取锁，则失败

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

## 执行 echo 命令前，获取排他锁
$ flock -x local-lock-file echo 'a b c'

## shell 脚本中使用很方便，当块中的代码执行完成时，文件描述符9和锁会自动释放
## 此处还可以使用 subshell, 但subshell存在一定的性能损耗，以及一些其他类似变量传递等的问题
$ {
 flock -n 9 || exit 1
 # ... commands executed under lock ...
} 9>/var/lock/mylockfile
  
## 这是 shell 脚本的样板代码。将它放在要锁定的 shell 脚本的顶部，它会在第一次运行时自动锁定。
## 如果 env var $FLOCKER 未设置为正在运行的 shell 脚本，则在重新执行自身之前执行 flock 并获取独占非阻塞锁（使用脚本本身作为锁文件）。 
## 它还将 FLOCKER 环境变量设置为正确的值，因此它不会再次运行。
$ [ "${FLOCKER}" != "$0" ] && exec env FLOCKER="$0" flock -en "$0" "$0" "$@" || :

1
2
3

#include <sys/file.h> 

int flock(int fd, int operation);