use std::thread;
use std::time::Duration;

fn main() {
    // 创建一个新线程
    let handle = thread::spawn(|| {
        for i in 1..=5 {
            println!("Thread: Count {}", i);
            thread::sleep(Duration::from_millis(500));
        }
    });

    // 主线程继续执行其他操作
    for i in 1..=3 {
        println!("Main Thread: Count {}", i);
        thread::sleep(Duration::from_millis(1000));
    }

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

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

fn main() {
    // 创建一个通道
    let (sender, receiver) = mpsc::channel();

    // 创建一个新线程，发送消息
    thread::spawn(move || {
        let val = String::from("Hello from the other side");
        sender.send(val).unwrap();
    });

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

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    // 创建一个可变共享状态
    let counter = Arc::new(Mutex::new(0));

    // 克隆 Arc，用于多线程共享
    let counter_clone = Arc::clone(&counter);

    // 创建多个线程，修改共享状态
    let handles: Vec<_> = (0..5)
        .map(|_| {
            let counter = Arc::clone(&counter_clone);
            thread::spawn(move || {
                let mut num = counter.lock().unwrap();
                *num += 1;
            })
        })
        .collect();

    // 等待所有线程结束
    for handle in handles {
        handle.join().unwrap();
    }

    // 打印最终结果
    println!("Result: {}", *counter.lock().unwrap());
}