SendWrapper

这个Rust库实现了一个名为SendWrapper的包装类型，它允许你在不同线程之间移动非Send类型，只要你只在原始线程中访问包含的值。你还需要确保包装器在原始线程中被丢弃。如果违反了这些约束条件中的任何一个，将会发生panic。

这个库的想法是在基于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;
// 这个导入很重要。它允许你使用deref(), deref_mut()或Deref强制转换来解包值
use std::ops::{Deref, DerefMut};
// Rc是一个非Send类型
let value = Rc::new(42);
// 我们现在用SendWrapper包装这个值(值被移动进去)
let wrapped_value = SendWrapper::new(value);
// 通道允许我们在线程之间移动包装值
let (sender, receiver) = channel();
let t = thread::spawn(move || {
// 这会panic(因为在错误的线程中解引用):
// let value = wrapped_value.deref();
<span class="hljs-comment">// 将SendWrapper移回主线程，这样它可以从那里被丢弃</span>
<span class="hljs-comment">// 如果省略这个，线程会因为从错误的线程丢弃而panic</span>
sender.<span class="hljs-title function_ invoke__">send</span>(wrapped_value).<span class="hljs-title function_ invoke__">unwrap</span>();
});
let wrapped_value = receiver.recv().unwrap();
// 现在你可以再次使用这个值
let value = wrapped_value.deref();
// 解引用的替代方案:
// let value = *wrapped_value;
// let value: &NonSendType = &wrapped_value;
// 可变解引用的替代方案(value和wrapped_value也必须是可变的):
// let mut value = wrapped_value.deref_mut();
// let mut value = &mut *wrapped_value;
// let mut value: &mut NonSendType = &mut wrapped_value;

完整示例

下面是一个更完整的示例，展示了如何在异步环境中使用SendWrapper：

use send_wrapper::SendWrapper;
use std::rc::Rc;
use std::thread;
use std::sync::mpsc::channel;
use std::ops::{Deref, DerefMut};

fn main() {
    // 创建一个非Send的Rc值
    let rc_value = Rc::new(42);
    
    // 使用SendWrapper包装它
    let wrapped = SendWrapper::new(rc_value);
    
    // 创建一个通道用于线程间通信
    let (tx, rx) = channel();
    
    // 在主线程中保存原始线程ID
    let original_thread = thread::current().id();
    
    // 启动一个新线程
    let handle = thread::spawn(move || {
        println!("Worker thread: {:?}", thread::current().id());
        
        // 尝试在错误的线程中访问会panic
        // let value = wrapped.deref(); // 这会panic!
        
        // 将包装器发送回主线程
        tx.send(wrapped).unwrap();
    });
    
    // 在主线程中接收包装器
    let wrapped = rx.recv().unwrap();
    
    // 检查是否在原始线程中
    assert_eq!(thread::current().id(), original_thread);
    
    // 安全地解引用
    let value = wrapped.deref();
    println!("Main thread got value: {}", value);
    
    // 等待工作线程完成
    handle.join().unwrap();
}

许可证

send_wrapper同时根据MIT许可证和Apache许可证(2.0版)分发。

h691938207 1楼

parity-send-wrapper: Rust异步消息发送库的使用指南

概述

parity-send-wrapper 是一个 Rust 库，专门用于实现高效、跨线程的安全通信与数据传递。它提供了简单易用的异步消息发送机制，特别适合需要在线程间传递数据的并发应用场景。

主要特性

线程安全的消息传递
轻量级包装器设计
支持异步/await 语法
高效的数据传输
与标准库良好集成

安装

在 Cargo.toml 中添加依赖：

[dependencies]
parity-send-wrapper = "0.1"

基本使用方法

1. 创建消息通道

use parity_send_wrapper::SendWrapper;

// 创建同步消息通道
let (sender, receiver) = SendWrapper::channel();

2. 跨线程发送消息

use std::thread;

// 创建通道
let (sender, receiver) = SendWrapper::channel();

// 在新线程中发送消息
let handle = thread::spawn(move || {
    sender.send("Hello from another thread!").unwrap();
});

// 在主线程接收消息
let received = receiver.recv().unwrap();
println!("Received: {}", received);

// 等待线程结束
handle.join().unwrap();

3. 异步消息处理

use tokio::runtime::Runtime;

// 创建Tokio运行时
let rt = Runtime::new().unwrap();
rt.block_on(async {
    // 创建异步通道
    let (async_sender, mut async_receiver) = SendWrapper::async_channel();
    
    // 在异步任务中发送消息
    tokio::spawn(async move {
        async_sender.send("Async message").await.unwrap();
    });
    
    // 接收异步消息
    if let Some(msg) = async_receiver.recv().await {
        println!("Received async: {}", msg);
    }
});

高级用法

1. 发送复杂类型

#[derive(Debug)]
struct ComplexData {
    id: u32,
    name: String,
    values: Vec<f64>,
}

// 创建通道
let (sender, receiver) = SendWrapper::channel();

// 在新线程中发送复杂数据结构
thread::spawn(move || {
    let data = ComplexData {
        id: 42,
        name: "Example".to_string(),
        values: vec![1.0, 2.0, 3.0],
    };
    sender.send(data).unwrap();
});

// 接收并打印复杂数据
let received = receiver.recv().unwrap();
println!("Received complex data: {:?}", received);

2. 多生产者单消费者模式

// 创建通道
let (sender, receiver) = SendWrapper::channel();
// 克隆发送端
let sender2 = sender.clone();

// 第一个生产者线程
thread::spawn(move || {
    sender.send("First").unwrap();
});

// 第二个生产者线程
thread::spawn(move || {
    sender2.send("Second").unwrap();
});

// 消费者接收消息
println!("{}", receiver.recv().unwrap());
println!("{}", receiver.recv().unwrap());

3. 超时接收

use std::time::Duration;

// 创建通道
let (sender, receiver) = SendWrapper::channel();

// 带超时的接收
match receiver.recv_timeout(Duration::from_secs(1)) {
    Ok(msg) => println!("Got: {}", msg),
    Err(e) => println!("Timeout: {:?}", e),
}

性能提示

对于高频小消息，考虑批量发送
大对象传递时使用 Arc 包装可以减少拷贝开销
合理设置通道容量以避免内存问题

错误处理

// 创建通道
let (sender, receiver) = SendWrapper::channel();
// 显式丢弃接收端
drop(receiver); 

// 尝试发送消息到已关闭的接收端
match sender.send("test") {
    Ok(_) => println!("Sent successfully"),
    Err(e) => println!("Failed to send: {:?}", e),
}

完整示例代码

use parity_send_wrapper::SendWrapper;
use std::thread;
use std::time::Duration;
use tokio::runtime::Runtime;

// 定义复杂数据结构
#[derive(Debug)]
struct ComplexData {
    id: u32,
    name: String,
    values: Vec<f64>,
}

fn main() {
    // 示例1: 基本同步通信
    let (sender, receiver) = SendWrapper::channel();
    thread::spawn(move || {
        sender.send("Hello from thread").unwrap();
    });
    println!("同步接收: {}", receiver.recv().unwrap());

    // 示例2: 异步通信
    let rt = Runtime::new().unwrap();
    rt.block_on(async {
        let (async_sender, mut async_receiver) = SendWrapper::async_channel();
        tokio::spawn(async move {
            async_sender.send("Async hello").await.unwrap();
        });
        if let Some(msg) = async_receiver.recv().await {
            println!("异步接收: {}", msg);
        }
    });

    // 示例3: 发送复杂类型
    let (complex_sender, complex_receiver) = SendWrapper::channel();
    thread::spawn(move || {
        let data = ComplexData {
            id: 1,
            name: "Test".to_string(),
            values: vec![1.1, 2.2],
        };
        complex_sender.send(data).unwrap();
    });
    println!("复杂数据: {:?}", complex_receiver.recv().unwrap());

    // 示例4: 多生产者
    let (multi_sender, multi_receiver) = SendWrapper::channel();
    let sender1 = multi_sender.clone();
    let sender2 = multi_sender.clone();
    
    thread::spawn(move || { sender1.send("消息1").unwrap(); });
    thread::spawn(move || { sender2.send("消息2").unwrap(); });
    
    println!("多生产者: {}", multi_receiver.recv().unwrap());
    println!("多生产者: {}", multi_receiver.recv().unwrap());

    // 示例5: 超时接收
    let (timeout_sender, timeout_receiver) = SendWrapper::channel();
    thread::spawn(move || {
        thread::sleep(Duration::from_millis(1500));
        timeout_sender.send("迟到的消息").unwrap();
    });
    match timeout_receiver.recv_timeout(Duration::from_secs(1)) {
        Ok(msg) => println!("收到: {}", msg),
        Err(_) => println!("接收超时"),
    }
}

总结

parity-send-wrapper 提供了简单而强大的线程间通信机制，适合各种并发场景。通过合理使用同步和异步通道，可以构建高效可靠的 Rust 并发应用。

Rust异步消息发送库parity-send-wrapper的使用，实现高效跨线程安全通信与数据传递