use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let messages = vec!["hello", "world", "from", "thread"];
        for msg in messages {
            tx.send(msg.to_string()).unwrap();
            thread::sleep(std::time::Duration::from_millis(200));
        }
    });

    // 接收消息（阻塞）
    for received in rx {
        println!("收到: {}", received);
    }
}

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();
    let mut handles = vec![];

    for i in 0..3 {
        let tx_clone = tx.clone();
        let handle = thread::spawn(move || {
            let msg = format!("线程 {} 的消息", i);
            tx_clone.send(msg).unwrap();
        });
        handles.push(handle);
    }

    drop(tx);  // 关闭原始发送端

    for received in rx {
        println!("{}", received);
    }

    for handle in handles {
        handle.join().unwrap();
    }
}

use std::sync::mpsc;
use std::thread;

fn main() {
    // 最多缓冲 5 条消息
    let (tx, rx) = mpsc::sync_channel(5);

    thread::spawn(move || {
        for i in 0..10 {
            println!("发送 {}", i);
            tx.send(i).unwrap();  // 超过 5 条时会阻塞
        }
    });

    for received in rx {
        println!("收到: {}", received);
        thread::sleep(std::time::Duration::from_millis(200));
    }
}

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        thread::sleep(Duration::from_secs(1));
        tx.send("delayed message").unwrap();
    });

    loop {
        match rx.try_recv() {
            Ok(msg) => {
                println!("收到: {}", msg);
                break;
            }
            Err(mpsc::TryRecvError::Empty) => {
                println!("暂无消息，继续工作...");
                thread::sleep(Duration::from_millis(300));
            }
            Err(mpsc::TryRecvError::Disconnected) => {
                println!("发送端已关闭");
                break;
            }
        }
    }
}

use std::sync::mpsc;
use std::thread;

enum LogLevel {
    Info(String),
    Warn(String),
    Error(String),
}

fn logger(rx: mpsc::Receiver<LogLevel>) {
    for log in rx {
        match log {
            LogLevel::Info(msg) => println!("[INFO] {}", msg),
            LogLevel::Warn(msg) => println!("[WARN] {}", msg),
            LogLevel::Error(msg) => eprintln!("[ERROR] {}", msg),
        }
    }
}

fn main() {
    let (tx, rx) = mpsc::channel();

    let logger_handle = thread::spawn(move || logger(rx));

    for i in 0..5 {
        let tx = tx.clone();
        thread::spawn(move || {
            tx.send(LogLevel::Info(format!("Worker {} 完成任务", i))).unwrap();
        });
    }

    drop(tx);
    logger_handle.join().unwrap();
}