多线程写入同一文件是否线程安全？如何用内置模块或外部crate实现安全写入？

1. 多线程直接写入同一文件是否线程安全？ #

不安全。你提供的示例代码中，两个线程各自打开独立的File句柄和BufWriter，写入操作完全没有同步机制。操作系统不会自动保证多线程写入的原子性，当多个线程同时向文件写入时，字节流会交错拼接，最终导致文件内容混杂错乱，这就是你遇到的数据混杂问题的根源。

另外，std::fs::File本身并不实现Sync trait，无法安全地跨线程共享同一个实例；你的代码中每个线程单独打开文件，虽然能通过编译，但本质是多个独立句柄并发写入，同样会引发数据竞争和内容错乱。

2. 如何实现线程安全的文件写入（无需手动处理排他性）？ #

方法一：使用Rust标准库的同步原语封装 #

可以用std::sync::Mutex包裹文件写入器，结合Arc实现跨线程共享，让同一时间只有一个线程能执行写入操作：

use std::io::{BufWriter, Write};
use std::path::PathBuf;
use std::fs::{File, OpenOptions};
use std::thread;
use std::sync::{Arc, Mutex};

fn write_to_file(writer: Arc<Mutex<BufWriter<File>>>) {
    println!("{:?}", thread::current().id());
    let file_str = format!("{:?}: {:?}\n", "/home/harry/a.txt", thread::current().id());
    
    // 获取锁，同一时间仅一个线程能操作写入器
    let mut locked_writer = writer.lock().unwrap();
    for _ in 0..1000000 {
        locked_writer.write(file_str.as_bytes()).expect("无法写入文件");
    }
    locked_writer.flush().expect("无法刷新文件缓存");
}

fn create_file(file_path: PathBuf) {
    File::create(file_path).expect("文件创建失败");
}

fn main() {
    let file_path = PathBuf::from("/home/harry/a.txt");
    create_file(file_path.clone());

    let file = OpenOptions::new()
        .write(true)
        .open(&file_path)
        .unwrap();
    // 用Arc+Mutex封装线程安全的写入器
    let writer = Arc::new(Mutex::new(BufWriter::new(file)));

    let writer1 = Arc::clone(&writer);
    let writer2 = Arc::clone(&writer);

    let jh1 = thread::spawn(move || write_to_file(writer1));
    let jh2 = thread::spawn(move || write_to_file(writer2));

    let _ = jh1.join();
    let _ = jh2.join();
}

这里Arc负责跨线程共享所有权，Mutex自动处理排他性，无需手动实现锁逻辑，就能保证写入操作的原子性。

方法二：使用外部crate实现生产者-消费者模式 #

如果想彻底避免锁的使用，可以用生产者-消费者模式：让一个专门的线程负责文件写入，其他线程只发送要写入的数据。比如用crossbeam-channel crate实现：

use std::io::{BufWriter, Write};
use std::path::PathBuf;
use std::fs::{File, OpenOptions};
use std::thread;
use crossbeam_channel::{unbounded, Sender, Receiver};

// 专门负责写入的工作线程
fn write_worker(rx: Receiver<String>, file_path: PathBuf) {
    let file = OpenOptions::new()
        .write(true)
        .open(file_path)
        .unwrap();
    let mut buf_writer = BufWriter::new(file);
    
    // 接收并写入所有消息
    while let Ok(msg) = rx.recv() {
        buf_writer.write(msg.as_bytes()).expect("无法写入文件");
    }
    buf_writer.flush().expect("无法刷新文件缓存");
}

fn write_to_file(tx: Sender<String>) {
    println!("{:?}", thread::current().id());
    let file_str = format!("{:?}: {:?}\n", "/home/harry/a.txt", thread::current().id());
    
    for _ in 0..1000000 {
        tx.send(file_str.clone()).expect("消息发送失败");
    }
}

fn create_file(file_path: PathBuf) {
    File::create(file_path).expect("文件创建失败");
}

fn main() {
    let file_path = PathBuf::from("/home/harry/a.txt");
    create_file(file_path.clone());

    // 创建无界通道
    let (tx, rx) = unbounded();

    // 启动写入工作线程
    let worker_handle = thread::spawn(move || write_worker(rx, file_path));

    let tx1 = tx.clone();
    let tx2 = tx.clone();

    let jh1 = thread::spawn(move || write_to_file(tx1));
    let jh2 = thread::spawn(move || write_to_file(tx2));

    let _ = jh1.join();
    let _ = jh2.join();
    drop(tx); // 关闭通道，通知工作线程退出
    let _ = worker_handle.join();
}

这种模式下，所有写入操作由单个线程完成，天然避免了并发冲突，无需处理任何锁逻辑，代码逻辑更清晰。

总结 #

• 多线程独立打开文件写入绝对不安全，必然导致内容错乱；
• 标准库的Arc<Mutex>可以轻松实现线程安全写入，自动处理排他性；
• 生产者-消费者模式能彻底避免并发写入问题，是更优雅的实现方式。

内容的提问来源于stack exchange，提问作者Harry