Your concurrency patterns, line for line.

10.1The lay of the land

Here's the whole map up front; the rest of the chapter works through the common ones with side-by-side code.

10.2Interlocked → atomic types

Atomic counters and flags map straight onto std::sync::atomic. The one new thing is that Rust asks you to name the memory ordering; C#'s Interlocked is always fully sequenced, whereas Rust lets you say "this counter doesn't coordinate with other data, so the cheapest ordering is fine."

private long _requests;

// hot path, many threads
Interlocked.Increment(ref _requests);
long n = Interlocked.Read(ref _requests);

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

static REQUESTS: AtomicU64 = AtomicU64::new(0);

REQUESTS.fetch_add(1, Ordering::Relaxed);
let n = REQUESTS.load(Ordering::Relaxed);

10.3lock (obj) {} → Mutex<T>

The everyday lock statement becomes Mutex<T>, with one structural upgrade: in Rust the mutex owns the data it protects, so there's no way to touch the data without locking.

private readonly object _lock = new();
private int _ticks;

void Bump() {
    lock (_lock) { _ticks++; }
}

use std::sync::Mutex;

let ticks = Mutex::new(0);

// the i32 lives INSIDE the mutex
*ticks.lock().unwrap() += 1;

10.4ConcurrentDictionary → DashMap (or RwLock<HashMap>)

There's no concurrent hash map in std, but the dashmap crate is a close drop-in: internally sharded, no single global lock, with an entry(...).or_insert_with(...) that mirrors GetOrAdd.

static readonly ConcurrentDictionary<string, Session>
    Cache = new();

var s = Cache.GetOrAdd(id, _ => new Session());
Cache.TryRemove(id, out _);

use dashmap::DashMap;
use std::sync::LazyLock;

static CACHE: LazyLock<DashMap<String, Session>>
    = LazyLock::new(DashMap::new);

let s = CACHE.entry(id).or_insert_with(Session::new);
CACHE.remove(&id);

If you'd rather stay in the standard library, Arc<RwLock<HashMap<K,V>>> works: .read() for lookups, .write() for inserts. DashMap tends to win when many threads read and write across many keys — the cache/registry shape you see most.

The "swap the whole map" drain

A pattern that shows up for batching: atomically replace the entire dictionary with a fresh one and process the old contents (Interlocked.Exchange(ref _pending, new())). With a std map behind a lock, that's std::mem::take — it moves the contents out and leaves an empty map in place, no clone.

ConcurrentDictionary<long, byte> _pending = new();

var drained =
    Interlocked.Exchange(ref _pending, new());

let pending = Mutex::new(HashMap::new());

let drained =
    std::mem::take(&mut *pending.lock().unwrap());

10.5Lazy<T> → LazyLock / OnceLock

The thread-safe lazy singleton — extremely common for managers, caches, and compiled regexes — is LazyLock<T> in std (Rust 1.80+). Like Lazy<T>, the initializer runs exactly once on first access.

static readonly Lazy<Manager> Instance =
    new(() => new Manager());

// first .Value runs the factory, once
Manager m = Instance.Value;

use std::sync::LazyLock;

static INSTANCE: LazyLock<Manager> =
    LazyLock::new(|| Manager::new());

// first deref runs the closure, once
let m: &Manager = &INSTANCE;

10.6SemaphoreSlim → tokio::sync::Semaphore

For throttling async work — limit N concurrent operations, or a count-1 gate around a lazy load — tokio::sync::Semaphore is the match. The ergonomic difference: there's no try/finally to Release(), because the permit releases itself when dropped.

private readonly SemaphoreSlim _gate = new(1, 1);

await _gate.WaitAsync(ct);
try {
    // critical async section
} finally {
    _gate.Release();
}

use tokio::sync::Semaphore;

let gate = Semaphore::new(1);

let permit = gate.acquire().await.unwrap();
// critical async section
// permit auto-released when it drops — no finally

10.7CancellationToken → tokio cancellation

The most common pattern in both codebases — a background loop that runs until shutdown — ports cleanly. tokio_util even keeps the name CancellationToken, and select! (ch. 6's Task.WhenAny) is how you race real work against the shutdown signal.

protected override async Task ExecuteAsync(
    CancellationToken stop) {
  while (!stop.IsCancellationRequested) {
    await DoWorkAsync(stop);
    await Task.Delay(1000, stop);
  }
}

use tokio_util::sync::CancellationToken;

async fn run(stop: CancellationToken) {
  loop {
    tokio::select! {
      _ = stop.cancelled() => break,
      _ = do_work() => {}
    }
    tokio::time::sleep(Duration::from_secs(1)).await;
  }
}

10.8What's std vs. a crate

So you know what needs a cargo add: