实现带共享访问的env_logger自定义日志目标：所有权问题修复求助

需要为env_logger实现自定义日志目标，同时用另一个线程并发访问该目标处理日志数据，但当前代码因所有权问题无法编译。

原代码 #

use std::{thread};
use std::sync::Mutex;

pub struct MyTarget {
    some_value: u64,
    buffer: Mutex<String>,
}

impl std::io::Write for MyTarget {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
    std::io::stdout().write_all(buf).unwrap();
    Ok(buf.len())
}

fn flush(&mut self) -> std::io::Result<()> {
    Ok(())
}
}

impl MyTarget {
    fn deliver_logs_loop(&mut self) {
        loop {
            // ...
        }
    }
}

fn main() {
    let dummy_settings = 123;
    let mut target = MyTarget{some_value: dummy_settings, buffer: Mutex::new(String::new())};

    env_logger::Builder::new()
        .target(env_logger::Target::Pipe(Box::new(target)))
        .init();

    thread::spawn(move || {
        target.deliver_logs_loop();
    });
}

编译错误 #

Compiling playground v0.0.1 (/playground)
error[E0382]: use of moved value: `target`
--> src/main.rs:36:19
|
30 |     let mut target = MyTarget{some_value: dummy_settings, buffer: Mutex::new(String::new())};
|         ---------- move occurs because `target` has type `MyTarget`, which does not implement the `Copy` trait
...
33 |         .target(env_logger::Target::Pipe(Box::new(target)))
|                                                   ------ value moved here
...
36 |     thread::spawn(move || {
|                   ^^^^^^^ value used here after move
37 |         target.deliver_logs_loop();
|         ------ use occurs due to use in closure

For more information about this error, try `rustc --explain E0382`.
error: could not compile `playground` (bin "playground") due to 1 previous error

解决方案 #

问题核心是target被移动到env_logger::Target::Pipe后，无法再被后台线程使用。要实现跨线程共享，需要用Arc（原子引用计数）实现共享所有权，结合Mutex保证线程安全的可变访问。

修改后的完整代码：

use std::{thread, sync::{Arc, Mutex}};
use std::io::Write;

pub struct MyTarget {
    some_value: u64,
    buffer: Mutex<String>,
}

impl MyTarget {
    fn write_inner(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        std::io::stdout().write_all(buf).unwrap();
        // 同时写入缓冲区供后台线程处理
        let mut buffer = self.buffer.lock().unwrap();
        buffer.push_str(String::from_utf8_lossy(buf).as_ref());
        Ok(buf.len())
    }

    fn flush_inner(&mut self) -> std::io::Result<()> {
        Ok(())
    }

    fn deliver_logs_loop(&mut self) {
        loop {
            // 示例：定期取出缓冲区内容处理
            let mut buffer = self.buffer.lock().unwrap();
            if !buffer.is_empty() {
                // 处理日志数据，这里仅打印示例
                println!("处理日志: {}", buffer);
                buffer.clear();
            }
            thread::sleep(std::time::Duration::from_secs(1));
        }
    }
}

// 包装器，实现Write trait，通过Arc<Mutex<MyTarget>>共享访问
struct PipeWrapper(Arc<Mutex<MyTarget>>);

impl Write for PipeWrapper {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        let mut target = self.0.lock().unwrap();
        target.write_inner(buf)
    }

    fn flush(&mut self) -> std::io::Result<()> {
        let mut target = self.0.lock().unwrap();
        target.flush_inner()
    }
}

fn main() {
    let dummy_settings = 123;
    let target = Arc::new(Mutex::new(MyTarget{
        some_value: dummy_settings, 
        buffer: Mutex::new(String::new())
    }));

    // 克隆Arc给后台线程
    let target_clone = Arc::clone(&target);
    thread::spawn(move || {
        let mut target = target_clone.lock().unwrap();
        target.deliver_logs_loop();
    });

    // 初始化env_logger，传入包装器
    env_logger::Builder::new()
        .target(env_logger::Target::Pipe(Box::new(PipeWrapper(target))))
        .init();

    // 测试日志输出
    log::info!("测试日志消息");
}

关键改动说明 #

1. 共享所有权：用Arc<Mutex<MyTarget>>包裹MyTarget，Arc允许多个线程持有同一实例的引用，Mutex保证同一时间只有一个线程能获取可变访问权。
2. Write包装器：创建PipeWrapper结构体持有Arc<Mutex<MyTarget>>，并实现Write trait，内部通过锁获取MyTarget的可变引用后调用实际的写入逻辑。
3. 线程传递：克隆Arc实例传给后台线程，避免所有权移动问题，后台线程通过锁获取MyTarget后调用处理循环。

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