[dependencies]
# 同步緩存
moka = { version = "0.12", features = ["sync"] }
# 異步緩存
moka = { version = "0.12", features = ["future"] }
tokio = { version = "1", features = ["full"] }
anyhow = "1.0"

use moka::sync::Cache;

fn main() {
    // 創(chuàng)建緩存：最大容量1000條數(shù)據(jù)，超過(guò)容量將按 TinyLFU 算法淘汰
    let cache = Cache::builder()
        .max_capacity(1000) // 核心配置：緩存最大條目數(shù)
        .build();

    // 插入數(shù)據(jù)
    cache.insert("user:1", "張三");
    cache.insert("user:2", "李四");

    // 獲取數(shù)據(jù)（返回 Option<T>，不存在則返回 None）
    if let Some(name) = cache.get(&"user:1") {
        println!("獲取緩存：{}", name);
    }

    // 刪除指定數(shù)據(jù)（兩種方式：invalidate 無(wú)返回值，remove 會(huì)返回被刪除的值）
    // invalidate 刪除數(shù)據(jù)無(wú)返回值
    cache.invalidate(&"user:2");
    // remove 刪除數(shù)據(jù)并返回被刪除的值
    let removed = cache.remove("user:1"); // 返回 Option<T>，此處為 Some("王五")
    println!("被刪除的值：{:?}", removed);

    // 清空所有緩存，謹(jǐn)慎使用，生產(chǎn)環(huán)境需避免誤操作
    cache.invalidate_all();

    //  獲取緩存當(dāng)前條目數(shù)
    println!("緩存當(dāng)前大?。簕}", cache.entry_count());
}

use moka::sync::Cache;
use std::time::Duration;

fn main() {
    // 創(chuàng)建帶過(guò)期策略的緩存：存活60秒（TTL），空閑30秒（TTI）
    let cache = Cache::builder()
        .max_capacity(100)
        .time_to_live(Duration::from_secs(60)) // 插入后，60秒內(nèi)有效
        .time_to_idle(Duration::from_secs(30)) // 最后一次訪問(wèn)后，30秒內(nèi)無(wú)訪問(wèn)則失效
        .build();

    cache.insert("key1", "value1");

    // 5秒后訪問(wèn)，刷新 TTI 計(jì)時(shí)
    std::thread::sleep(Duration::from_secs(5));
    if let Some(val) = cache.get(&"key1") {
        println!("5秒后訪問(wèn)：{}", val); // 輸出：5秒后訪問(wèn)：value1
    }

    // 再等待35秒（累計(jì)空閑35秒，超過(guò) TTI 30秒）
    std::thread::sleep(Duration::from_secs(35));
    if cache.get(&"key1").is_none() {
        println!("35秒后，緩存已失效（TTL未到，但TTI超時(shí)）");
    }

    // 插入新數(shù)據(jù)，測(cè)試 TTL
    cache.insert("key2", "value2");
    std::thread::sleep(Duration::from_secs(65)); // 超過(guò) TTL 60秒
    if cache.get(&"key2").is_none() {
        println!("65秒后，緩存已失效（TTL超時(shí)）");
    }
}

use moka::future::Cache;
use std::time::Duration;

#[tokio::main]
async fn main() {
    //創(chuàng)建異步緩存：最大容量1000，TTL 60秒
    let cache = Cache::builder()
        .max_capacity(1000)
        .time_to_live(Duration::from_secs(60))
        .build();

    // 異步插入
    cache.insert("user:100", "趙六").await;

    // 異步獲取
    if let Some(name) = cache.get(&"user:100").await {
        println!("異步獲取緩存：{}", name); // 輸出：異步獲取緩存：趙六
    }

    // 異步刪除
    cache.invalidate(&"user:100").await;

    // 異步原子填充：get_with（不存在則計(jì)算并插入，避免并發(fā)重復(fù)計(jì)算）
    // 場(chǎng)景：緩存不存在時(shí)，從數(shù)據(jù)庫(kù)查詢并插入緩存，這里模擬耗時(shí)操作
    let user = cache
        .get_with("user:101", async {
            tokio::time::sleep(Duration::from_millis(50)).await;
            "孫七"
        })
        .await;
    println!("原子填充緩存：{}", user); // 輸出：原子填充緩存：孫七
}

use moka::sync::Cache;
use std::sync::Arc;

fn main() {
    // 用 Arc 包裝大值
    let cache = Cache::new(1000);
    let large_value = Arc::new("大字符串...".repeat(10000));
    cache.insert("key", large_value);

    // 獲取時(shí)克隆 Arc（成本極低，僅增加引用計(jì)數(shù)）
    if let Some(val) = cache.get(&"key") {
        let inner_val = &*val; // 無(wú)需克隆內(nèi)部值，直接引用
    }
}