rust - 将调试数据转储到 Rust 中的静态文件的代码紧凑线程安全方法是什么？

Question

我正在测试一些 Rust 代码，并希望将一些中间数据记录到一个文件中，以确保它是正确的，然后再将下一个元素写入使用该数据的管道中。在任何其他语言中，我只是将数据写入存储在静态变量中的文件句柄，但 rust 提示(正确地)这不是线程安全的。由于相关应用程序使用 gstreamer，这在理论上是一种威胁。我将在下面粘贴我的天真版本:

use std::fs::File;
use std::io::Write;

fn main() {
    log_mesh("bacon");
}

static mut meshes : Option<Result<File, std::io::Error>> = None;

fn log_mesh(message: &str)
{
    if let None = meshes {
        meshes = Some(File::open("/tmp/meshes.txt"));
    }

    if let Ok(mut f) = meshes.unwrap() {
        f.write_all(message.as_bytes());
        f.flush();
    }
}

这会导致两种重要的编译错误:

error[E0507]: cannot move out of static item
  --> src/main.rs:16:24
   |
16 |     if let Ok(mut f) = meshes.unwrap() {
   |                        ^^^^^^ cannot move out of static item

error[E0133]: use of mutable static is unsafe and requires unsafe function or block
  --> src/main.rs:12:19
   |
12 |     if let None = meshes {
   |                   ^^^^^^ use of mutable static
   |
   = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior

我曾在 Mutex、lazy_static!、mut_static 中游刃有余，但所有这些都让我陷入困境，我迷路了。我认为必须有一些简洁的习语来解决这个问题，而这个问题不会出现在 Google 搜索结果中。

Answer 1

lazy_static! 的第一次尝试是

use lazy_static::lazy_static;
use std::sync::Mutex;

use std::fs::File;
use std::io::Write;


lazy_static! {
static ref meshes : Mutex<Result<File, std::io::Error>> = Mutex::new(File::open("/tmp/meshes.txt"));
}

pub fn log_mesh(message: &str)
{
    let mut tmp = meshes.lock().unwrap();

    if let Ok(ref mut f) = tmp {
        f.write_all(message.as_bytes());
        f.flush();
    }
}

触发此编译错误:

error[E0308]: mismatched types
  --> src/module2.rs:16:12
   |
16 |     if let Ok(ref mut f) = tmp {
   |            ^^^^^^^^^^^^^   --- this match expression has type `std::sync::MutexGuard<'_, std::result::Result<std::fs::File, std::io::Error>>`
   |            |
   |            expected struct `std::sync::MutexGuard`, found enum `std::result::Result`
   |
   = note: expected type `std::sync::MutexGuard<'_, std::result::Result<std::fs::File, std::io::Error>, >`
              found type `std::result::Result<_, _>`

这有点令人沮丧，充满了幕后魔法，但可以通过将其更改为来解决

    if let Ok(ref mut f) = *tmp {

我不愿将其标记为答案，因为更有经验的编码人员可能会发现竞争条件或其他更高级的习惯用法。