fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1 的所有权移动到 s2

    // println!("{}", s1); // ❌ 编译错误：s1 已失效
    println!("{}", s2);    // ✅ 正常使用
}

use std::thread;

fn main() {
    let mut data = vec![1, 2, 3];

    // 所有权移动到新线程
    let handle = thread::spawn(move || {
        data.push(4);
        println!("子线程: {:?}", data);
    });

    // println!("{:?}", data); // ❌ 编译错误：data 已移动
    handle.join().unwrap();
}

fn main() {
    // 使用迭代器链（高级抽象）
    let sum: i32 = (1..=100)
        .filter(|x| x % 2 == 0)
        .map(|x| x * x)
        .sum();

    println!("1到100中偶数的平方和: {}", sum);
    // 编译器会将上述代码优化为与手写循环同样高效的机器码
}

fn main() {
    {
        let s = String::from("hello"); // s 是有效所有者
        println!("{}", s);
    } // s 离开作用域，String 被自动释放（调用 drop）

    // println!("{}", s); // ❌ 编译错误：s 已不存在
}

fn main() {
    let mut s = String::from("hello");

    let r1 = &s;     // ✅ 不可变引用
    let r2 = &s;     // ✅ 不可变引用
    println!("{} {}", r1, r2);
    // r1 和 r2 在此之后不再使用（NLL）

    let r3 = &mut s; // ✅ 可变引用（此时 r1、r2 已失效）
    r3.push_str(", world");
    println!("{}", r3);
}

// 情况 1: 使用迭代器
fn sum_squares_iterator(n: u64) -> u64 {
    (1..=n).map(|x| x * x).sum()
}

// 情况 2: 使用手写循环
fn sum_squares_loop(n: u64) -> u64 {
    let mut sum = 0u64;
    for x in 1..=n {
        sum += x * x;
    }
    sum
}

fn main() {
    let n = 1000;
    println!("迭代器: {}", sum_squares_iterator(n));
    println!("手写循环: {}", sum_squares_loop(n));
    // 两种方式生成的机器码几乎完全相同
}

// 泛型函数
fn max_value<T: PartialOrd>(a: T, b: T) -> T {
    if a >= b { a } else { b }
}

fn main() {
    // 编译器会生成两个版本：
    // max_value_i32(a: i32, b: i32) -> i32
    // max_value_f64(a: f64, b: f64) -> f64
    println!("{}", max_value(10, 20));
    println!("{}", max_value(3.14, 2.71));
}

use std::collections::HashMap;

/// 分析文本中每个单词的出现次数
fn word_count(text: &str) -> HashMap<&str, usize> {
    let mut counts = HashMap::new();
    for word in text.split_whitespace() {
        // entry API：键不存在则插入默认值，返回可变引用
        let count = counts.entry(word).or_insert(0);
        *count += 1;
    }
    counts
}

fn main() {
    let text = "hello world hello rust hello world";
    let counts = word_count(text);

    println!("单词统计结果：");
    for (word, count) in &counts {
        println!("  \"{}\" 出现 {} 次", word, count);
    }
}

use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::time::Instant;

/// 请求计数器（线程安全，无需锁）
struct RequestCounter {
    total: AtomicU64,
    errors: AtomicU64,
    start_time: Instant,
}

impl RequestCounter {
    fn new() -> Self {
        Self {
            total: AtomicU64::new(0),
            errors: AtomicU64::new(0),
            start_time: Instant::now(),
        }
    }

    fn record_request(&self, is_error: bool) {
        self.total.fetch_add(1, Ordering::Relaxed);
        if is_error {
            self.errors.fetch_add(1, Ordering::Relaxed);
        }
    }

    fn report(&self) {
        let elapsed = self.start_time().elapsed().as_secs_f64();
        let total = self.total.load(Ordering::Relaxed);
        let errors = self.errors.load(Ordering::Relaxed);
        let qps = total as f64 / elapsed;

        println!("总请求数: {}", total);
        println!("错误数:   {}", errors);
        println!("QPS:      {:.2}", qps);
    }
}

fn main() {
    let counter = Arc::new(RequestCounter::new());

    // 模拟多线程并发请求
    let handles: Vec<_> = (0..10)
        .map(|_| {
            let counter = Arc::clone(&counter);
            std::thread::spawn(move || {
                for i in 0..1000 {
                    counter.record_request(i % 50 == 0); // 每50个请求一个错误
                }
            })
        })
        .collect();

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

    counter.report();
}