Send & Sync

use std::thread;

fn main() {
    let data = String::from("Hello");

    thread::spawn(move || {
        // OK : String est Send, on peut le déplacer dans un autre thread
        println!("{}", data);
    });
}

use std::rc::Rc;
use std::thread;

fn main() {
    let data = Rc::new(String::from("Hello"));

    // ERREUR : Rc<String> n'est pas Send !
    thread::spawn(move || {
        println!("{}", data);
    });
}

error[E0277]: `Rc<String>` cannot be sent between threads safely
   = help: the trait `Send` is not implemented for `Rc<String>`

T is Sync  ⇒  &T is Send

Si T implémente Sync, une référence &T peut être envoyée entre threads.

use std::thread;
use std::sync::Arc;

fn main() {
    let data = Arc::new(String::from("Hello"));
    let data_ref = Arc::clone(&data);

    thread::spawn(move || {
        // OK : String est Sync, donc &String est Send.
        // Arc permet de partager la référence entre threads.
        println!("{}", data_ref);
    });

    println!("{}", data);
}

// Trait générique illustratif pour un formulaire
pub trait FormulaireTrait: Send + Sync {   // ← Sync important !
    fn new() -> Self;
    fn validate(&mut self, raw_data: &HashMap<String, String>) -> bool;
}

// Sans Sync, une erreur de ce type peut survenir dans un extracteur Axum :
#[async_trait]
impl<S, T> FromRequest<S> for AxumForm<T>
where
    T: FormulaireTrait + 'static,   // ← doit être Send + Sync
{
    async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
        // Cette future peut être déplacée entre threads par Tokio.
        // Si T n'est pas Sync et qu'une référence &T existe à travers un .await,
        // le compilateur rejette le code.
    }
}

use std::cell::Cell;

// Ce code ne compile PAS :
pub struct BadForm {
    inner: Forms,
    counter: Cell<u32>,   // Cell n'est pas Sync !
}

impl FormulaireTrait for BadForm {
    fn new() -> Self {
        Self { inner: Forms::new(), counter: Cell::new(0) }
    }
    fn validate(&mut self, raw_data: &HashMap<String, String>) -> bool {
        self.counter.set(self.counter.get() + 1);
        self.inner.is_valid()
    }
}

error[E0277]: `Cell<u32>` cannot be shared between threads safely
   = help: the trait `Sync` is not implemented for `Cell<u32>`

use std::sync::atomic::{AtomicU32, Ordering};

// Ce code compile :
pub struct GoodForm {
    inner: Forms,
    counter: AtomicU32,   // AtomicU32 est Send + Sync
}

impl FormulaireTrait for GoodForm {
    fn new() -> Self {
        Self { inner: Forms::new(), counter: AtomicU32::new(0) }
    }
    fn validate(&mut self, raw_data: &HashMap<String, String>) -> bool {
        self.counter.fetch_add(1, Ordering::Relaxed);
        self.inner.is_valid()
    }
}

// Erreur
use std::rc::Rc;

async fn handler(data: Rc<String>) {
    // Erreur : Rc n'est pas Send
}

// Solution
use std::sync::Arc;

async fn handler(data: Arc<String>) {
    // OK : Arc est Send + Sync
}

// Erreur
use std::cell::Cell;

struct MyStruct {
    value: Cell<i32>,   // Cell n'est pas Sync
}

// Solution : utiliser un type atomique
use std::sync::atomic::{AtomicI32, Ordering};

struct MyStruct {
    value: AtomicI32,   // AtomicI32 est Send + Sync
}

// Risque futur : Send seul suffit aujourd'hui mais bloquera dès qu'un usage
// exigera Sync
pub trait MyTrait: Send {
    // ...
}

// Meilleure pratique : poser les deux bounds dès le départ si le trait
// est destiné à un contexte partagé/async
pub trait MyTrait: Send + Sync {
    // ...
}

use std::sync::Arc;
use tokio::sync::Mutex;

#[derive(Clone)]
struct AppState {
    counter: Arc<Mutex<i32>>,   // Mutex<T> est Sync si T: Send
    config: Arc<Settings>,      // Arc<T> est Sync si T: Sync
}

async fn handler(State(state): State<AppState>) -> Response {
    // OK : AppState est Send + Sync
    let mut counter = state.counter.lock().await;
    *counter += 1;
    // ...
}

// Ce code ne compile pas. Pourquoi ? Comment le corriger ?
use std::rc::Rc;
use std::thread;

fn main() {
    let data = Rc::new(vec![1, 2, 3]);
    thread::spawn(move || {
        println!("{:?}", data);
    });
}

// Problème : Rc n'est pas Send, impossible de le déplacer dans un thread.
// Solution : utiliser Arc à la place.
use std::sync::Arc;   // ← changement ici
use std::thread;

fn main() {
    let data = Arc::new(vec![1, 2, 3]);   // ← Arc au lieu de Rc
    thread::spawn(move || {
        println!("{:?}", data);
    });
}
// Compile et fonctionne.

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

// Trait thread-safe pour cache
pub trait CacheTrait: Send + Sync {
    type Key: Send + Sync;
    type Value: Send + Sync;

    fn get(&self, key: &Self::Key) -> Option<Self::Value>;
    fn set(&self, key: Self::Key, value: Self::Value);
}

// Implémentation avec Mutex
pub struct Cache<K, V> {
    data: Arc<Mutex<HashMap<K, V>>>,
}

impl<K, V> Cache<K, V>
where
    K: Send + Sync + Eq + std::hash::Hash + Clone,
    V: Send + Sync + Clone,
{
    pub fn new() -> Self {
        Self { data: Arc::new(Mutex::new(HashMap::new())) }
    }
}

impl<K, V> CacheTrait for Cache<K, V>
where
    K: Send + Sync + Eq + std::hash::Hash + Clone,
    V: Send + Sync + Clone,
{
    type Key = K;
    type Value = V;

    fn get(&self, key: &Self::Key) -> Option<Self::Value> {
        self.data.lock().unwrap().get(key).cloned()
    }
    fn set(&self, key: Self::Key, value: Self::Value) {
        self.data.lock().unwrap().insert(key, value);
    }
}
// Ce cache est Send + Sync et utilisable dans du code async.