在之前关于 RcWriter 的文章中,我们将 Rc 智能型指针和「Writer」一同连用,让「Writer」的拥有权在被其他套件抢走之后还可以有办法继续使用同样的「Writer」。但如果是在并发与并行的程序中,「RcWriter」就无用武之地了。

为了解释这个问题,我们用以下这个程序来说明:

use std::io::{self, Write};

pub struct Logger<W: Write> {
    writer: W
}

impl<W: Write> Logger<W> {
    pub fn new(writer: W) -> Logger<W> {
        Logger {
            writer
        }
    }

    pub fn write_log_line(&mut self, log: &str) -> Result<(), io::Error> {
        self.writer.write(log.as_bytes())?;
        self.writer.write(b"\n")?;
        self.writer.flush()?;

        Ok(())
    }
}
mod log;

use std::rc::Rc;
use std::cell::RefCell;

use std::io::{self, Write};
use std::thread;

pub struct RcWriter<W: Write> {
    inner: Rc<RefCell<W>>
}

impl<W: Write> RcWriter<W> {
    pub fn new(writer: Rc<RefCell<W>>) -> RcWriter<W> {
        RcWriter {
            inner: writer
        }
    }
}

impl<W: Write> Write for RcWriter<W> {
    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
        self.inner.borrow_mut().write(buf)
    }

    fn flush(&mut self) -> Result<(), io::Error> {
        self.inner.borrow_mut().flush()
    }
}

fn main() {
    let log_result: Rc<RefCell<Vec<u8>>> = Rc::new(RefCell::new(Vec::new()));

    let mut threads = Vec::with_capacity(10);

    for _ in 0..10 {
        let log_result_writer = RcWriter::new(Rc::clone(&log_result));

        let mut logger = log::Logger::new(log_result_writer);

        let thread = thread::spawn(move || {
            logger.write_log_line("New log!!").unwrap();
        });

        threads.push(thread);
    }

    for thread in threads {
        thread.join().unwrap();
    }

    println!("{:?}", log_result.borrow());
}

以上程序会编译失败,因为 Rc 智能型指针并不是 thread-safe 的设计,无法跨线程使用。为了能够让 RcWriter 被用在不同的线程上,我们可以参考这篇文章的说明,改用 Arc 和 Mutex 智能型指针来取代 Rc 和 RefCell 吧!

Synchronized Writer

「Synchronized Writer」是笔者开发的套件,将这篇文章介绍的「Rc Writer」套件,以 Arc 和 Mutex 智能型指针来实作,使其可以跨线程使用。

Crates.io

Cargo.toml

synchronized-writer = "*"

使用方法

以上程序可以用 synchronized_writer 这个 crate 所提供的 SynchronizedWriter 结构体改写如下:

mod log;

use synchronized_writer::SynchronizedWriter;

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

fn main() {
    let log_result: Arc<Mutex<Vec<u8>>> = Arc::new(Mutex::new(Vec::new()));

    let mut threads = Vec::with_capacity(10);

    for _ in 0..10 {
        let log_result_writer = SynchronizedWriter::new(Arc::clone(&log_result));

        let mut logger = log::Logger::new(log_result_writer);

        let thread = thread::spawn(move || {
            logger.write_log_line("New log!!").unwrap();
        });

        threads.push(thread);
    }

    for thread in threads {
        thread.join().unwrap();
    }

    println!("{:?}", *log_result.lock().unwrap());
}

如果想要取回「Writer」的拥有权,可以用 SynchronizedOptionWriter 结构体改写成:

mod log;

use synchronized_writer::SynchronizedOptionWriter;

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

fn main() {
    let log_result: Arc<Mutex<Option<Vec<u8>>>> = Arc::new(Mutex::new(Some(Vec::new())));

    let mut threads = Vec::with_capacity(10);

    for _ in 0..10 {
        let log_result_writer = SynchronizedOptionWriter::new(Arc::clone(&log_result));

        let mut logger = log::Logger::new(log_result_writer);

        let thread = thread::spawn(move || {
            logger.write_log_line("New log!!").unwrap();
        });

        threads.push(thread);
    }

    for thread in threads {
        thread.join().unwrap();
    }

    println!("{:?}", log_result.lock().unwrap().take());
}