SendWrapper

此 Rust 库实现了一个名为 SendWrapper 的包装类型，它允许你在线程之间移动非 Send 类型的值，只要您只从原始线程中访问包含的值。您还必须确保从原始线程中丢弃包装器。如果违反了这些约束中的任何一个，就会发生恐慌。

这个库的想法是在一个基于 GTK+/gtk-rs 的应用程序的背景下产生的。 GTK+ 应用程序是严格单线程的。不允许从主线程以外的线程调用任何 GTK+ 方法。因此，所有 gtk-rs 结构都是非 Send。

有时你仍然想在后台做一些工作。你可以使用 Glib 将 GTK+ 调用入队，以在主线程中执行。这样，您可以知道涉及的 gtk-rs 结构只会在主线程中访问并在那里丢弃。这个库使得 gtk-rs 结构可以离开主线程，就像所要求的那样

文档

示例

use send_wrapper::SendWrapper;
use std::rc::Rc;
use std::thread;
use std::sync::mpsc::channel;

// This import is important. It allows you to unwrap the value using deref(),
// deref_mut() or Deref coercion.
use std::ops::{Deref, DerefMut};

// Rc is a non-Send type.
let value = Rc::new(42);

// We now wrap the value with `SendWrapper` (value is moved inside).
let wrapped_value = SendWrapper::new(value);

// A channel allows us to move the wrapped value between threads.
let (sender, receiver) = channel();

let t = thread::spawn(move || {

	// This would panic (because of dereferencing in wrong thread):
	// let value = wrapped_value.deref();

	// Move SendWrapper back to main thread, so it can be dropped from there.
	// If you leave this out the thread will panic because of dropping from wrong thread.
	sender.send(wrapped_value).unwrap();

});

let wrapped_value = receiver.recv().unwrap();

// Now you can use the value again.
let value = wrapped_value.deref();

// alternatives for dereferencing:
// let value = *wrapped_value;
// let value: &NonSendType = &wrapped_value;

// alternatives for mutable dereferencing (value and wrapped_value must be mutable too, then):
// let mut value = wrapped_value.deref_mut();
// let mut value = &mut *wrapped_value;
// let mut value: &mut NonSendType = &mut wrapped_value;

许可证

send_wrapper 采用 MIT 许可证和 Apache 许可证（版本 2.0）的条款进行分发。

详细信息请参阅 LICENSE-APACHE 和 LICENSE-MIT。