当前位置：首页 > Linux > 正文

linux 如何独占性的打开一个文件

admin
Linux
2025-07-12
2487

Linux中，可使用 open()函数并指定 O_EXCL标志来独占性打开文件

Linux系统中，独占性地打开一个文件意味着确保该文件在被当前进程访问时，其他进程无法同时对其进行操作，这通常用于防止数据竞争、确保数据一致性或实现文件锁定等场景,以下是几种在Linux中独占性地打开文件的方法：

使用系统调用`open`

open系统调用是Linux中用于打开文件的底层函数，它提供了丰富的标志位来控制文件的打开方式，通过设置合适的标志位,可以实现文件的独占性打开。

标志位	含义
`O_RDONLY`	以只读方式打开文件
`O_WRONLY`	以只写方式打开文件
`O_RDWR`	以读写方式打开文件
`O_CREAT`	如果文件不存在则创建文件
`O_EXCL`	与`O_CREAT`一起使用，如果文件已存在则返回错误
`O_TRUNC`	如果文件已存在，则将其长度截断为0
`O_APPEND`	以追加模式打开文件，写入的数据总是添加到文件末尾
`O_NONBLOCK`	以非阻塞方式打开文件
`O_EXCL`	与`O_CREAT`一起使用，确保文件的独占性创建

示例代码（C语言）：

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
int main() {
    int fd = open("test.txt", O_RDWR | O_CREAT | O_EXCL, 0666);
    if (fd == -1) {
        if (errno == EEXIST) {
            printf("File already exists.
");
        } else {
            perror("open");
        }
        return 1;
    }
    // 文件成功以独占方式打开，可以进行读写操作
    // ...
    close(fd);
    return 0;
}

在上述代码中，O_CREAT | O_EXCL组合确保了如果文件已存在，则open调用会失败,从而保证了文件的独占性创建。

linux 如何独占性的打开一个文件第1张

使用文件锁（`flock`）

flock是一个用于管理文件锁的系统调用，它可以对文件描述符进行加锁和解锁操作，通过flock,可以实现对文件的独占性访问。

示例代码（C语言）：

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/file.h>
#include <errno.h>
int main() {
    int fd = open("test.txt", O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
        perror("open");
        return 1;
    }
    // 尝试对文件加独占锁
    if (flock(fd, LOCK_EX) == -1) {
        if (errno == EWOULDBLOCK) {
            printf("File is already locked by another process.
");
        } else {
            perror("flock");
        }
        close(fd);
        return 1;
    }
    // 文件成功加锁，可以进行独占性操作
    // ...
    // 解锁并关闭文件
    if (flock(fd, LOCK_UN) == -1) {
        perror("flock");
    }
    close(fd);
    return 0;
}

在上述代码中，flock(fd, LOCK_EX)尝试对文件描述符fd加独占锁，如果文件已被其他进程锁定，则flock会返回-1并设置errno为EWOULDBLOCK。

使用`fcntl`设置文件描述符属性

fcntl函数可以用于获取和设置文件描述符的属性，包括文件锁，通过fcntl,可以实现对文件的独占性锁定。

示例代码（C语言）：

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
int main() {
    int fd = open("test.txt", O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
        perror("open");
        return 1;
    }
    // 设置文件描述符为非阻塞模式
    int flags = fcntl(fd, F_GETFL);
    if (flags == -1) {
        perror("fcntl");
        close(fd);
        return 1;
    }
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl");
        close(fd);
        return 1;
    }
    // 尝试对文件加独占锁
    struct flock lock;
    lock.l_type = F_WRLCK; // 写锁，即独占锁
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0; // 锁定整个文件
    if (fcntl(fd, F_SETLK, &lock) == -1) {
        if (errno == EAGAIN || errno == EACCES) {
            printf("File is already locked by another process.
");
        } else {
            perror("fcntl");
        }
        close(fd);
        return 1;
    }
    // 文件成功加锁，可以进行独占性操作
    // ...
    // 解锁并关闭文件
    lock.l_type = F_UNLCK;
    if (fcntl(fd, F_SETLK, &lock) == -1) {
        perror("fcntl");
    }
    close(fd);
    return 0;
}

在上述代码中，fcntl(fd, F_SETLK, &lock)尝试对文件加独占锁，如果文件已被其他进程锁定，则fcntl会返回-1并设置errno为EAGAIN或EACCES。

使用数据库事务（针对数据库文件）

如果文件是数据库文件，那么可以使用数据库提供的事务机制来实现独占性访问，在SQLite中，可以通过BEGIN TRANSACTION和COMMIT来开启和提交事务,从而确保在事务期间对数据库文件的独占性访问。

示例代码（SQLite）：

BEGIN TRANSACTION;
-执行SQL操作，这些操作在事务提交前都是独占的
INSERT INTO table_name (column1, column2) VALUES (value1, value2);
UPDATE table_name SET column1 = value1 WHERE condition;
-...
COMMIT;

在上述SQL代码中，BEGIN TRANSACTION开启了一个事务，之后的所有SQL操作都是在事务上下文中执行的，直到COMMIT提交事务，在事务提交之前，其他进程无法对这些数据进行修改,从而实现了独占性访问。