Python `fcntl` / `mmap`：Unix/Linux 底层文件与内存操作

好的，各位观众老爷，欢迎来到今天的“Python fcntl / mmap：Unix/Linux 底层文件与内存操作”专场表演。今天咱们不讲玄乎的理论，直接撸代码，带你体验一把什么叫做“手搓文件”，感受一下 Unix/Linux 系统底层文件操作的魅力。

开场白：为什么要玩底层？

你可能会问，Python 不是号称“人生苦短，我用 Python”吗？为啥还要搞这么底层的玩意儿？难道我写个 open()，read()，write() 还不够用吗？

当然够用！对于大多数应用场景，Python 内置的文件操作已经足够强大。但是，总有一些时候，你需要更精细的控制，更极致的性能，或者更骚气的操作。例如：

• 文件锁： 保证多个进程同时访问同一个文件时的安全性，防止数据错乱。
• 内存映射： 将文件直接映射到内存，实现超高速的文件读写，尤其适合处理超大文件。
• 更底层的文件控制： 修改文件属性、控制 I/O 行为等等。

这个时候，Python 标准库中的 fcntl 和 mmap 模块就派上用场了。它们提供了对 Unix/Linux 系统底层文件操作接口的访问，让你可以像个真正的“黑客”一样，直接和操作系统对话。（当然，前提是你要知道你在说什么，不然可能会把自己坑了。）

第一幕：fcntl – 文件控制的艺术

fcntl 模块主要用于文件控制，包括文件锁、文件状态标志等等。 咱们先从最常用的文件锁开始。

1. 文件锁：锁住你的数据，保护你的贞操

想象一下，多个程序同时修改同一个文件，如果没有锁的保护，那场面简直就是一场灾难。 fcntl 模块提供了两种锁：

• flock()： 简单粗暴的锁，整个文件一把锁。
• fcntl()： 更精细的锁，可以锁定文件的部分区域。

咱们先看 flock() 的用法：

import fcntl
import time

filename = "test.txt"

# 确保文件存在
with open(filename, "a") as f:
    pass

def acquire_lock(fd):
    try:
        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB) # LOCK_EX排它锁，LOCK_NB非阻塞
        print("获取锁成功！")
        return True
    except OSError:
        print("获取锁失败，文件已被锁定！")
        return False

def release_lock(fd):
    fcntl.flock(fd, fcntl.LOCK_UN) # 释放锁
    print("释放锁成功！")

# 模拟一个进程
with open(filename, "w") as f:
    fd = f.fileno()  # 获取文件描述符

    if acquire_lock(fd):
        try:
            print("正在写入数据...")
            f.write("Hello, world!")
            time.sleep(5)  # 模拟耗时操作
            print("写入完成！")
        finally:
            release_lock(fd)
    else:
        print("无法获取锁，程序退出。")

这段代码演示了如何使用 flock() 来获取和释放文件锁。 LOCK_EX 表示排它锁，也就是独占锁，只有一个进程可以获取到。 LOCK_NB 表示非阻塞模式，如果获取锁失败，会立即抛出一个 OSError 异常，而不是一直等待。

如果你运行两个以上的脚本同时写入 test.txt，你会发现只有一个脚本能够成功写入，其他的脚本会因为无法获取锁而退出。

友情提示： flock() 锁是进程级别的，也就是说，同一个进程内的多个线程无法使用 flock() 锁来同步。

2. fcntl()：更精细的锁，锁住你的局部

fcntl() 函数提供了更强大的文件锁控制，它可以锁定文件的部分区域，而不是整个文件。 它的用法稍微复杂一些，需要用到一个 struct 结构体来描述锁定的区域。

import fcntl
import struct
import time

filename = "test.txt"

# 确保文件存在
with open(filename, "a") as f:
    pass

# 定义锁的结构体
lockdata = struct.pack('hhllhh', fcntl.F_WRLCK, 0, 0, 0, 0, 0)  # 读锁fcntl.F_RDLCK，写锁fcntl.F_WRLCK
# 第一个h：short int l_type;  锁的类型（F_RDLCK, F_WRLCK, F_UNLCK）
# 第二个h：short int l_whence; 起始位置（SEEK_SET, SEEK_CUR, SEEK_END）
# 第一个l：off_t l_start;    起始偏移量
# 第二个l：off_t l_len;      锁定长度，0 表示锁定到文件末尾
# 第三个h：pid_t l_pid;      持有锁的进程 ID (一般设置为 0)
# 第四个h：int   l_sysid;    系统 ID (一般设置为 0)

def acquire_lock(fd, start, length):
    lockdata = struct.pack('hhllhh', fcntl.F_WRLCK, 0, start, length, 0, 0)
    try:
        fcntl.fcntl(fd, fcntl.F_SETLK, lockdata)  # F_SETLK非阻塞, F_SETLKW阻塞
        print(f"获取锁成功！锁定区域：{start}-{start + length}")
        return True
    except OSError:
        print("获取锁失败，文件已被锁定！")
        return False

def release_lock(fd, start, length):
    lockdata = struct.pack('hhllhh', fcntl.F_UNLCK, 0, start, length, 0, 0)
    fcntl.fcntl(fd, fcntl.F_SETLK, lockdata)
    print(f"释放锁成功！释放区域：{start}-{start + length}")

# 模拟一个进程
with open(filename, "w") as f:
    fd = f.fileno()  # 获取文件描述符

    start = 0
    length = 10

    if acquire_lock(fd, start, length):
        try:
            print("正在写入数据...")
            f.seek(start)
            f.write("Hello, world!"[:length])  # 只写入锁定区域
            time.sleep(5)  # 模拟耗时操作
            print("写入完成！")
        finally:
            release_lock(fd, start, length)
    else:
        print("无法获取锁，程序退出。")

这段代码演示了如何使用 fcntl() 来锁定文件的部分区域。struct.pack() 函数用于将数据打包成 C 结构体格式，fcntl.F_SETLK 用于设置锁。 F_SETLK 是非阻塞模式，如果获取锁失败，会立即抛出一个 OSError 异常。 F_SETLKW 是阻塞模式，如果获取锁失败，会一直等待直到获取到锁或者被信号中断。

3. 其他 fcntl 操作

fcntl 模块还提供了其他一些有用的函数，例如：

• fcntl.fcntl(fd, fcntl.F_GETFL)：获取文件状态标志。
• fcntl.fcntl(fd, fcntl.F_SETFL, flags)：设置文件状态标志。
• fcntl.ioctl(fd, request, arg)：执行设备相关的 I/O 控制命令。

这些函数可以让你更精细地控制文件的行为，但是需要对 Unix/Linux 系统底层的文件操作有更深入的了解。

第二幕：mmap – 内存映射的魔法

mmap 模块可以将文件或者设备映射到内存中，然后像访问内存一样访问文件，从而实现超高速的文件读写。

1. 创建内存映射

import mmap

filename = "test.txt"

# 确保文件存在，并且足够大
with open(filename, "wb") as f:
    f.seek(1024 * 1024)  # 1MB
    f.write(b"")  # 写入一个空字节，扩展文件大小

# 创建内存映射
with open(filename, "r+b") as f:
    mm = mmap.mmap(f.fileno(), 0)  # 0表示映射整个文件，也可指定长度
    # 参数依次是文件描述符，映射长度，访问模式（可省略，默认是mmap.ACCESS_DEFAULT，即读写模式）

    # 通过内存映射访问文件
    mm[0:5] = b"Hello"
    print(mm[0:5])  # 输出: b'Hello'

    mm.close()

这段代码演示了如何使用 mmap 模块创建一个内存映射。 mmap.mmap() 函数用于创建内存映射，第一个参数是文件描述符，第二个参数是映射的长度，如果设置为 0，则映射整个文件。

注意事项：

• 在创建内存映射之前，需要确保文件存在，并且足够大。 如果文件不存在或者太小，会导致 OSError 异常。
• 内存映射的长度必须是系统页面大小的整数倍。 可以使用 os.sysconf("SC_PAGE_SIZE") 获取系统页面大小。
• 修改内存映射的内容会直接反映到文件中，所以要小心操作。

2. 访问内存映射

创建了内存映射之后，就可以像访问数组一样访问文件内容了。

import mmap

filename = "test.txt"

with open(filename, "r+b") as f:
    mm = mmap.mmap(f.fileno(), 0)

    # 读取数据
    print(mm[0:5])

    # 写入数据
    mm[6:11] = b"World"

    # 查找子字符串
    index = mm.find(b"World")
    print(f"找到 'World' 的位置：{index}")

    mm.close()

这段代码演示了如何使用内存映射来读取、写入和查找文件内容。 mmap 对象支持类似于字符串和字节数组的操作，例如切片、索引、查找等等。

3. 内存映射的优点

• 速度快： 内存映射直接在内存中操作文件，避免了内核缓冲区拷贝，所以速度非常快。
• 节省内存： 多个进程可以共享同一个内存映射，从而节省内存。
• 方便： 可以像访问数组一样访问文件内容，操作简单。

4. 内存映射的应用场景

• 超大文件读写： 可以轻松处理 TB 级别的大文件。
• 进程间通信： 多个进程可以通过共享内存映射来进行通信。
• 数据库： 许多数据库系统使用内存映射来提高性能。

第三幕：fcntl + mmap – 强强联合，天下我有

fcntl 和 mmap 可以结合使用，实现更强大的功能。 例如，可以使用 fcntl 来锁定文件的部分区域，然后使用 mmap 来访问锁定的区域。

import fcntl
import mmap
import struct
import time

filename = "test.txt"

# 确保文件存在，并且足够大
with open(filename, "wb") as f:
    f.seek(1024 * 1024)  # 1MB
    f.write(b"")

# 定义锁的结构体
def acquire_lock(fd, start, length):
    lockdata = struct.pack('hhllhh', fcntl.F_WRLCK, 0, start, length, 0, 0)
    try:
        fcntl.fcntl(fd, fcntl.F_SETLK, lockdata)
        print(f"获取锁成功！锁定区域：{start}-{start + length}")
        return True
    except OSError:
        print("获取锁失败，文件已被锁定！")
        return False

def release_lock(fd, start, length):
    lockdata = struct.pack('hhllhh', fcntl.F_UNLCK, 0, start, length, 0, 0)
    fcntl.fcntl(fd, fcntl.F_SETLK, lockdata)
    print(f"释放锁成功！释放区域：{start}-{start + length}")

# 模拟一个进程
with open(filename, "r+b") as f:
    fd = f.fileno()
    mm = mmap.mmap(fd, 0)

    start = 0
    length = 10

    if acquire_lock(fd, start, length):
        try:
            print("正在写入数据...")
            mm[start:start + length] = b"Hello!!!!"
            time.sleep(5)
            print("写入完成！")
        finally:
            release_lock(fd, start, length)
            mm.close()
    else:
        print("无法获取锁，程序退出。")

这段代码演示了如何使用 fcntl 来锁定文件的部分区域，然后使用 mmap 来修改锁定的区域。 这样可以保证多个进程同时访问同一个文件时的数据安全性。

第四幕：总结与展望

今天咱们一起学习了 Python fcntl 和 mmap 模块的基本用法，了解了如何使用它们来进行底层的文件操作。 fcntl 模块提供了文件锁等控制功能，可以保证多个进程同时访问同一个文件时的安全性。 mmap 模块可以将文件映射到内存中，实现超高速的文件读写。

未来展望：

• 深入研究 fcntl 模块的其他功能，例如文件状态标志、I/O 控制等等。
• 探索 mmap 模块的高级用法，例如共享内存、匿名映射等等。
• 将 fcntl 和 mmap 模块应用到实际项目中，解决实际问题。

彩蛋：一些幽默的小提示

• 使用 fcntl 和 mmap 模块需要对 Unix/Linux 系统底层的文件操作有一定的了解，否则可能会遇到一些奇怪的问题。 建议先阅读相关的文档和书籍，打好基础。
• fcntl 和 mmap 模块是强大的工具，但是也要小心使用，避免造成数据损坏或者系统崩溃。 建议在开发和测试环境中充分验证，然后再部署到生产环境。
• 不要试图用 fcntl 和 mmap 模块来解决所有问题，有时候简单的 open()，read()，write() 就足够了。 选择合适的工具，才能事半功倍。

最后，感谢各位观众老爷的观看，咱们下期再见！