Sharing Data in Axum State<T>, Arc<T>, Mutex<T> & RwLock<T>

use std::sync::Arc;

let config = Arc::new(AppConfig {
    db_url: "postgres://localhost/mydb".to_string(),
});

// Both config and config_clone point to the same allocation — no data is copied
let config_clone = Arc::clone(&config);

use axum::extract::State;

async fn hello_handler(State(config): State<Arc<AppConfig>>) -> String {
    format!("Connected to: {}", config.db_url)
}

let app = Router::new()
    .route("/hello", get(hello_handler))
    .with_state(Arc::new(config)); // 👈 attach once, available everywhere

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

let counter = Arc::new(Mutex::new(0u64));

// To read or write, you lock() first
let mut val = counter.lock().unwrap();
*val += 1;
// lock is automatically released when `val` is dropped

async fn increment(State(state): State<Arc<AppState>>) -> String {
    let mut count = state.counter.lock().unwrap();
    *count += 1;
    format!("Count is now: {}", *count)
}

// BAD — other tasks can't proceed while this one awaits
let data = state.items.lock().unwrap();
some_async_function().await; // 🔴 still holding the lock!

use std::sync::{Arc, RwLock};

let store = Arc::new(RwLock::new(vec!["hello".to_string()]));

// Multiple readers at the same time — fine!
let data = store.read().unwrap();
println!("{:?}", *data);

// One writer at a time — blocks until all readers are done
let mut data = store.write().unwrap();
data.push("world".to_string());

async fn get_items(State(state): State<Arc<AppState>>) -> String {
    let items = state.store.read().unwrap(); // 🔒 shared read lock
    items.join(", ")
}

async fn add_item(State(state): State<Arc<AppState>>) -> String {
    let mut items = state.store.write().unwrap(); // 🔒 exclusive write lock
    items.push("new item".to_string());
    format!("Total: {}", items.len())
}

// std::sync version — fine as long as you drop the lock before .await
{
    let mut data = state.cache.lock().unwrap();
    data.insert("key", "value"); // quick operation
} // lock dropped here ✅
some_async_call().await;

// tokio::sync version — needed if you must hold the lock across await
use tokio::sync::Mutex;
let mut data = state.cache.lock().await; // async lock acquisition
do_something_async().await; // safe to hold the lock here

Is your data read-only after startup?
  └── YES → Arc<T>  (no lock needed)
  └── NO (you need to mutate it)
        ├── Reads and writes happen equally?
        │     └── Arc<Mutex<T>>
        └── Reads are much more frequent than writes?
              └── Arc<RwLock<T>>

Do you need to hold the lock across .await points?
  └── YES → tokio::sync::Mutex / tokio::sync::RwLock
  └── NO  → std::sync::Mutex / std::sync::RwLock (preferred)

[dependencies]
axum = "0.8.9"
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

use axum::{
    extract::{Path, State},
    routing::{get, post},
    Json, Router,
};
use std::{
    collections::HashMap,
    sync::{Arc, RwLock},
};

// Our shared application state
struct AppState {
    // RwLock because reads (GET) will far outnumber writes (POST)
    store: RwLock<HashMap<String, String>>,
}

#[tokio::main]
async fn main() {
    let shared_state = Arc::new(AppState {
        store: RwLock::new(HashMap::new()),
    });

    let app = Router::new()
        .route("/store/{key}", get(get_value))
        .route("/store", post(set_value))
        .with_state(shared_state);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    println!("🚀 Listening on http://localhost:3000");
    axum::serve(listener, app).await.unwrap();
}

// GET /store/:key — many of these can run concurrently
async fn get_value(
    Path(key): Path<String>,
    State(state): State<Arc<AppState>>,
) -> String {
    let store = state.store.read().unwrap(); // shared read lock
    match store.get(&key) {
        Some(val) => val.clone(),
        None => format!("Key '{}' not found", key),
    }
} // read lock released here

// POST /store — exclusive write, blocks readers only for an instant
async fn set_value(
    State(state): State<Arc<AppState>>,
    Json(payload): Json<HashMap<String, String>>,
) -> String {
    let mut store = state.store.write().unwrap(); // exclusive write lock
    let count = payload.len();
    for (k, v) in payload {
        store.insert(k, v);
    }
    format!("Inserted {} key(s). Total keys: {}", count, store.len())
} // write lock released here

# Set some values
curl -X POST http://localhost:3000/store \
  -H "Content-Type: application/json" \
  -d '{"name": "Alice", "lang": "Rust"}'

# Read them back (concurrent reads are safe!)
curl http://localhost:3000/store/name
curl http://localhost:3000/store/lang

// ❌ This will either panic or cause a compile error
let lock = state.data.lock().unwrap();
some_async_fn().await; // still holding the lock!

// Read-only state (config, flags)
Arc<AppConfig>

// Mutable state, equal reads/writes
Arc<Mutex<T>>

// Mutable state, mostly reads
Arc<RwLock<T>>

// Mutable state, must hold lock across .await
Arc<tokio::sync::Mutex<T>>
Arc<tokio::sync::RwLock<T>>

// In your handler signature:
async fn my_handler(State(state): State<Arc<AppState>>) { ... }

// Attach to router:
Router::new()
    .route("/path", get(my_handler))
    .with_state(Arc::new(app_state))