• 栈（Stack）上的“浅拷贝”：非 Copy 类型（如 String）在栈上是一个固定大小的结构体，包含三个字段：堆内存指针（Pointer）、当前长度（Length）和容量（Capacity）。发生 move 时，CPU 会将这 3 个机器字（通常是 24 字节）从旧变量的栈空间复制到新变量的栈空间。
• 堆（Heap）上毫无变化：分配在堆上的实际文本数据保持原位，不会发生任何拷贝。

• 流分析（Dataflow Analysis）：编译器在编译时会追踪变量的状态。一旦发生 move，旧变量在语义上就被标记为“未初始化/冻结”状态。
• 零运行时开销：如果代码后面试图再次读取旧变量，编译器直接报错拒绝编译。在生成的机器码中，旧变量的析构函数（Drop）会被直接抹去（或通过条件标志位跳过），因此在运行时只有新变量在离开作用域时才会调用一次 Drop，确保绝对安全且没有任何多余开销。

• RefCell<T>（运行时借用检查）：它不提供任何并发锁机制。它只是把 Rust 的“不可变借用”和“可变借用”规则，从编译期推迟到了运行期。
• Mutex<T>（原子级并发锁）：它通过操作系统底层的互斥锁（以及 CPU 的原子指令）来确保在任何绝对的时间片内，有且仅有一个线程能够访问内部的数据。

• 如果强行在多线程中使用，当两个线程同时尝试修改这个计数器时，会发生数据竞争（Data Race）。
• 这会导致计数器损坏，从而让两个线程同时获取到内部数据的可变引用（&mut T），彻底破坏 Rust 的内存安全基石，引发未定义行为（Undefined Behavior）。

• RefCell<T> 内部的借用计数器不是线程安全的，因此 RefCell<T> 没有实现 Sync。
• 由于没有 Sync，你就无法将 &RefCell<T> 跨线程共享。如果你尝试用 Arc<RefCell<T>> 包裹它并传给新线程，编译器会直接报错，在编译阶段就把这种多线程隐患彻底掐死。

• 含义：它指的是被指向的数据在整个程序的运行期间都存活，且永远不会被释放。
• 经典场景：硬编码在代码里的字符串字面量（存储在编译产物的 .rodata 只读数据段中），或者通过 Box::leak 故意泄漏、使其永久常驻内存的对象。

• 含义：它约束的是类型 T 本身必须有能力活得和程序一样久。这意味着：类型 T 内部绝对不能包含任何带有“短生命周期”的借用引用。
• 通俗理解：
  • String 拥有其内部数据的所有权，不依赖任何外部借用。只要你不主动销毁它，它想活多久就能活多久。所以 String 满足 T: 'static。
  • &'a String 内部包含一个生命周期为 'a 的外部引用。它的存活受限于 'a。一旦 'a 结束，这个引用就失效了。因此它不满足 T: 'static（除非 'a 本身就是 'static）。

use std::cell::RefCell;
use std::sync::Arc;
use std::thread;

fn main() {
    // 创建一个被 Arc 包裹的 RefCell
    let data = Arc::new(RefCell::new(42));

    let data_clone = Arc::clone(&data);
    
    // 尝试开辟新线程，并在新线程中修改 RefCell 内部的值
    thread::spawn(move || {
        let mut val = data_clone.borrow_mut();
        *val += 1;
    });
}

error[E0277]: `RefCell<i32>` cannot be shared between threads safely
   --> src/main.rs:12:5
    |
12  |     thread::spawn(move || {
    |     ^^^^^^^^^^^^^ `RefCell<i32>` cannot be shared between threads safely
    |
    = help: within `[closure@src/main.rs:12:19: 12:26]`, the trait `Sync` is not implemented for `RefCell<i32>`
    = note: required because it appears within the type `Arc<RefCell<i32>>`
note: required by a bound in `spawn`

• the trait Sync is not implemented for RefCell<i32>：这是最关键的一句。Rust 编译器明确指出 RefCell 没有实现 Sync 这一特质。
• 无 Sync 导致闭包无法 Send：thread::spawn 要求传入的闭包必须实现 Send。而闭包捕获了 Arc<RefCell<i32>>。根据 Rust 的多线程规则：只有当 T: Sync 时，Arc<T> 才是 Send 的。由于 RefCell 不是 Sync，导致 Arc<RefCell> 不是 Send，最终闭包不是 Send，编译直接被拦截。

use std::thread;

// 定义一个普通的结构体，内部包含一个带有生命周期 'a 的引用
struct RefWrapper<'a> {
    inner_ref: &'a String,
}

// 模拟一个需要 'static 约束的函数（类似 thread::spawn 的内部约束）
fn requires_static_type<T: 'static>(_data: T) {
    // 这里的 T 必须有能力活得和程序一样久
}

fn main() {
    let local_string = String::from("我是局部变量，存在于 main 的栈帧中");

    // 构造一个包装器，借用了 local_string
    let wrapper = RefWrapper {
        inner_ref: &local_string,
    };

    // 尝试传入要求 'static 约束的函数
    requires_static_type(wrapper); 
}

error[E0310]: the parameter type `RefWrapper<'a>` may not live long enough
  --> src/main.rs:21:5
   |
21 |     requires_static_type(wrapper);
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `RefWrapper<'a>` will meet its required lifetime bounds
   |
help: consider adding an explicit lifetime bound...
   |
6  | struct RefWrapper<'a: 'static> {
   |                     +++++++++

• RefWrapper<'a> may not live long enough：编译器警告 RefWrapper 活得不够久。
• 类型生命周期不达标：requires_static_type 泛型函数要求传入的类型必须满足 T: 'static。然而，RefWrapper<'a> 的“生存能力”受限于它内部那个短命的引用 inner_ref（它的生命周期是 'a，只要 main 函数快结束了，local_string 被销毁，这个引用就失效了）。
• 如何修正：编译器给出了一个几乎不可能实现的建议 'a: 'static（即让传入的字符串引用永久常驻内存）。在实际工程中，正确的修正方法是消除引用，直接传递拥有所有权的数据（比如直接传 String，或者利用 Arc 共享所有权），从而彻底让类型摆脱 'a 的束缚，达到 T: 'static 的要求。