Async Local

Thread-safe pointers to thread-locals are possible

Traditionally the downside of thead-locals has been that usage is constrainted to the LocalKey::with closure with no lifetime escapement, the rationale being that anything beyond this is of an indeterminate lifetime. There is however a way around this limitation: by using a barrier to rendezvous worker threads during runtime shutdown, no tasks will outlive thread local data belonging to any worker thread, and all pointers to thread locals created within an async context and held therein will be of a valid lifetime. Utilizing this barrier mechanism, this crate introduces AsyncLocal::with_async, the async counterpart of LocalKey::with, as well as the unsafe pointer types and safety considerations foundational for using thread local data within an async context.

Optimal Runtime Configuration

By default, this crate makes no assumption about how the runtime is configured and utilizes Box::leak to prevent Context from deallocating T on drop. To disable this indirection and for best performance, enable the barrier-protected-runtime feature flag on async-local and configure the runtime using tokio::main or tokio::test macro with the crate attribute set to async_local. Doing so configures the runtime to use a barrier to rendezvous runtime workers during shutdown which ensures no async task outlives thread local data owned by runtime workers and obviates the need for Box::leak as a means of lifetime extension.

```rust

[cfg(test)]*

mod tests { use std::sync::atomic::{AtomicUsize, Ordering};

use async_local::{AsyncLocal, Context};

thread_local! { static COUNTER: Context = Context::new(AtomicUsize::new(0)); }

#[tokio::test(crate = "asynclocal", flavor = "multithread")] async fn itincrements() { COUNTER .withasync(|counter| { Box::pin(async move { counter.fetch_add(1, Ordering::Release); }) }) .await; } } ```