smux_rust 0.2.1

//! 多线程使用示例（异步版本）
//!
//! 这个示例展示了如何在异步环境中使用 smux_rust

use smux_rust::client;
use tokio::net::TcpStream;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("多线程使用示例（异步版本）");

    // 创建 TCP 连接
    let tcp_conn = TcpStream::connect("127.0.0.1:8080").await?;
    
    // 创建会话（返回 Arc<Session>，可以在多个任务间共享）
    let session = client(Box::new(tcp_conn), None).await?;
    println!("会话已创建，可以在多个任务间共享");

    // 示例 1: 多个任务打开不同的流
    println!("\n示例 1: 多个任务打开不同的流");
    let mut handles = Vec::new();
    
    for i in 0..3 {
        let session_clone = std::sync::Arc::clone(&session);
        let handle = tokio::spawn(async move {
            match session_clone.open_stream().await {
                Ok(mut stream) => {
                    let msg = format!("Hello from task {}", i);
                    stream.write_all(msg.as_bytes()).await.unwrap();
                    println!("任务 {} 打开流 {} 并发送: {}", i, stream.id(), msg);
                    
                    let mut buf = [0u8; 1024];
                    if let Ok(n) = stream.read(&mut buf).await {
                        println!("任务 {} 收到响应: {}", i, String::from_utf8_lossy(&buf[..n]));
                    }
                    
                    stream.close().await.unwrap();
                }
                Err(e) => {
                    eprintln!("任务 {} 打开流失败: {}", i, e);
                }
            }
        });
        handles.push(handle);
    }

    // 等待所有任务完成
    for handle in handles {
        handle.await.unwrap();
    }

    // 示例 2: 多个任务共享同一个流进行读取
    println!("\n示例 2: 多个任务共享同一个流进行读取");
    let stream = std::sync::Arc::new(session.open_stream().await?);
    
    let mut read_handles = Vec::new();
    for i in 0..2 {
        let stream_clone = std::sync::Arc::clone(&stream);
        let handle = tokio::spawn(async move {
            let mut buf = [0u8; 1024];
            // 注意：多个任务同时读取同一个流是安全的
            match stream_clone.read(&mut buf).await {
                Ok(n) if n > 0 => {
                    println!("读取任务 {} 读取到 {} 字节", i, n);
                }
                Ok(_) => {
                    println!("读取任务 {} 没有数据", i);
                }
                Err(e) => {
                    println!("读取任务 {} 错误: {}", i, e);
                }
            }
        });
        read_handles.push(handle);
    }

    // 等待读取任务完成
    for handle in read_handles {
        handle.await.unwrap();
    }

    // 示例 3: 并发打开多个流
    println!("\n示例 3: 并发打开多个流");
    let mut concurrent_handles = Vec::new();
    
    for i in 0..5 {
        let session_clone = std::sync::Arc::clone(&session);
        let handle = tokio::spawn(async move {
            tokio::time::sleep(tokio::time::Duration::from_millis(i * 10)).await;
            match session_clone.open_stream().await {
                Ok(stream) => {
                    println!("任务 {} 成功打开流 {}", i, stream.id());
                    stream.close().await.unwrap();
                }
                Err(e) => {
                    eprintln!("任务 {} 打开流失败: {}", i, e);
                }
            }
        });
        concurrent_handles.push(handle);
    }

    for handle in concurrent_handles {
        handle.await.unwrap();
    }

    // 关闭会话
    session.close().await?;
    println!("\n会话已关闭");

    Ok(())
}