在之前关于 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());
}
