1 // Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Thread local storage
13 #![unstable(feature = "thread_local_internals", issue = "0")]
19 /// A thread local storage key which owns its contents.
21 /// This key uses the fastest possible implementation available to it for the
22 /// target platform. It is instantiated with the [`thread_local!`] macro and the
23 /// primary method is the [`with`] method.
25 /// The [`with`] method yields a reference to the contained value which cannot be
26 /// sent across threads or escape the given closure.
28 /// # Initialization and Destruction
30 /// Initialization is dynamically performed on the first call to [`with`]
31 /// within a thread, and values that implement [`Drop`] get destructed when a
32 /// thread exits. Some caveats apply, which are explained below.
34 /// A `LocalKey`'s initializer cannot recursively depend on itself, and using
35 /// a `LocalKey` in this way will cause the initializer to infinitely recurse
36 /// on the first call to `with`.
41 /// use std::cell::RefCell;
44 /// thread_local!(static FOO: RefCell<u32> = RefCell::new(1));
47 /// assert_eq!(*f.borrow(), 1);
48 /// *f.borrow_mut() = 2;
51 /// // each thread starts out with the initial value of 1
52 /// thread::spawn(move|| {
54 /// assert_eq!(*f.borrow(), 1);
55 /// *f.borrow_mut() = 3;
59 /// // we retain our original value of 2 despite the child thread
61 /// assert_eq!(*f.borrow(), 2);
65 /// # Platform-specific behavior
67 /// Note that a "best effort" is made to ensure that destructors for types
68 /// stored in thread local storage are run, but not all platforms can guarantee
69 /// that destructors will be run for all types in thread local storage. For
70 /// example, there are a number of known caveats where destructors are not run:
72 /// 1. On Unix systems when pthread-based TLS is being used, destructors will
73 /// not be run for TLS values on the main thread when it exits. Note that the
74 /// application will exit immediately after the main thread exits as well.
75 /// 2. On all platforms it's possible for TLS to re-initialize other TLS slots
76 /// during destruction. Some platforms ensure that this cannot happen
77 /// infinitely by preventing re-initialization of any slot that has been
78 /// destroyed, but not all platforms have this guard. Those platforms that do
79 /// not guard typically have a synthetic limit after which point no more
80 /// destructors are run.
81 /// 3. On macOS, initializing TLS during destruction of other TLS slots can
82 /// sometimes cancel *all* destructors for the current thread, whether or not
83 /// the slots have already had their destructors run or not.
85 /// [`with`]: ../../std/thread/struct.LocalKey.html#method.with
86 /// [`thread_local!`]: ../../std/macro.thread_local.html
87 /// [`Drop`]: ../../std/ops/trait.Drop.html
88 #[stable(feature = "rust1", since = "1.0.0")]
89 pub struct LocalKey<T: 'static> {
90 // This outer `LocalKey<T>` type is what's going to be stored in statics,
91 // but actual data inside will sometimes be tagged with #[thread_local].
92 // It's not valid for a true static to reference a #[thread_local] static,
93 // so we get around that by exposing an accessor through a layer of function
94 // indirection (this thunk).
96 // Note that the thunk is itself unsafe because the returned lifetime of the
97 // slot where data lives, `'static`, is not actually valid. The lifetime
98 // here is actually slightly shorter than the currently running thread!
100 // Although this is an extra layer of indirection, it should in theory be
101 // trivially devirtualizable by LLVM because the value of `inner` never
102 // changes and the constant should be readonly within a crate. This mainly
103 // only runs into problems when TLS statics are exported across crates.
104 inner: unsafe fn() -> Option<&'static UnsafeCell<Option<T>>>,
106 // initialization routine to invoke to create a value
110 #[stable(feature = "std_debug", since = "1.16.0")]
111 impl<T: 'static> fmt::Debug for LocalKey<T> {
112 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
113 f.pad("LocalKey { .. }")
117 /// Declare a new thread local storage key of type [`std::thread::LocalKey`].
121 /// The macro wraps any number of static declarations and makes them thread local.
122 /// Publicity and attributes for each static are allowed. Example:
125 /// use std::cell::RefCell;
127 /// pub static FOO: RefCell<u32> = RefCell::new(1);
130 /// static BAR: RefCell<f32> = RefCell::new(1.0);
135 /// See [LocalKey documentation][`std::thread::LocalKey`] for more
138 /// [`std::thread::LocalKey`]: ../std/thread/struct.LocalKey.html
140 #[stable(feature = "rust1", since = "1.0.0")]
141 #[allow_internal_unstable]
142 macro_rules! thread_local {
143 // empty (base case for the recursion)
146 // process multiple declarations
147 ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = $init:expr; $($rest:tt)*) => (
148 __thread_local_inner!($(#[$attr])* $vis $name, $t, $init);
149 thread_local!($($rest)*);
152 // handle a single declaration
153 ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = $init:expr) => (
154 __thread_local_inner!($(#[$attr])* $vis $name, $t, $init);
159 #[unstable(feature = "thread_local_internals",
160 reason = "should not be necessary",
163 #[allow_internal_unstable]
164 #[allow_internal_unsafe]
165 macro_rules! __thread_local_inner {
166 (@key $(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $init:expr) => {
169 fn __init() -> $t { $init }
171 unsafe fn __getit() -> $crate::option::Option<
172 &'static $crate::cell::UnsafeCell<
173 $crate::option::Option<$t>>>
176 #[cfg(target_thread_local)]
177 static __KEY: $crate::thread::__FastLocalKeyInner<$t> =
178 $crate::thread::__FastLocalKeyInner::new();
180 #[cfg(not(target_thread_local))]
181 static __KEY: $crate::thread::__OsLocalKeyInner<$t> =
182 $crate::thread::__OsLocalKeyInner::new();
188 $crate::thread::LocalKey::new(__getit, __init)
192 ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $init:expr) => {
194 $(#[$attr])* $vis static $name: $crate::thread::LocalKey<$t> =
195 __thread_local_inner!(@key $(#[$attr])* $vis $name, $t, $init);
198 $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
199 __thread_local_inner!(@key $(#[$attr])* $vis $name, $t, $init);
203 /// Indicator of the state of a thread local storage key.
204 #[unstable(feature = "thread_local_state",
205 reason = "state querying was recently added",
207 #[derive(Debug, Eq, PartialEq, Copy, Clone)]
208 pub enum LocalKeyState {
209 /// All keys are in this state whenever a thread starts. Keys will
210 /// transition to the `Valid` state once the first call to [`with`] happens
211 /// and the initialization expression succeeds.
213 /// Keys in the `Uninitialized` state will yield a reference to the closure
214 /// passed to [`with`] so long as the initialization routine does not panic.
216 /// [`with`]: ../../std/thread/struct.LocalKey.html#method.with
219 /// Once a key has been accessed successfully, it will enter the `Valid`
220 /// state. Keys in the `Valid` state will remain so until the thread exits,
221 /// at which point the destructor will be run and the key will enter the
222 /// `Destroyed` state.
224 /// Keys in the `Valid` state will be guaranteed to yield a reference to the
225 /// closure passed to [`with`].
227 /// [`with`]: ../../std/thread/struct.LocalKey.html#method.with
230 /// When a thread exits, the destructors for keys will be run (if
231 /// necessary). While a destructor is running, and possibly after a
232 /// destructor has run, a key is in the `Destroyed` state.
234 /// Keys in the `Destroyed` states will trigger a panic when accessed via
237 /// [`with`]: ../../std/thread/struct.LocalKey.html#method.with
241 /// An error returned by [`LocalKey::try_with`](struct.LocalKey.html#method.try_with).
242 #[unstable(feature = "thread_local_state",
243 reason = "state querying was recently added",
245 pub struct AccessError {
249 #[unstable(feature = "thread_local_state",
250 reason = "state querying was recently added",
252 impl fmt::Debug for AccessError {
253 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
254 f.debug_struct("AccessError").finish()
258 #[unstable(feature = "thread_local_state",
259 reason = "state querying was recently added",
261 impl fmt::Display for AccessError {
262 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
263 fmt::Display::fmt("already destroyed", f)
267 impl<T: 'static> LocalKey<T> {
269 #[unstable(feature = "thread_local_internals",
270 reason = "recently added to create a key",
272 pub const unsafe fn new(inner: unsafe fn() -> Option<&'static UnsafeCell<Option<T>>>,
273 init: fn() -> T) -> LocalKey<T> {
280 /// Acquires a reference to the value in this TLS key.
282 /// This will lazily initialize the value if this thread has not referenced
287 /// This function will `panic!()` if the key currently has its
288 /// destructor running, and it **may** panic if the destructor has
289 /// previously been run for this thread.
290 #[stable(feature = "rust1", since = "1.0.0")]
291 pub fn with<F, R>(&'static self, f: F) -> R
292 where F: FnOnce(&T) -> R {
293 self.try_with(f).expect("cannot access a TLS value during or \
294 after it is destroyed")
297 unsafe fn init(&self, slot: &UnsafeCell<Option<T>>) -> &T {
298 // Execute the initialization up front, *then* move it into our slot,
299 // just in case initialization fails.
300 let value = (self.init)();
301 let ptr = slot.get();
303 // note that this can in theory just be `*ptr = Some(value)`, but due to
304 // the compiler will currently codegen that pattern with something like:
306 // ptr::drop_in_place(ptr)
307 // ptr::write(ptr, Some(value))
309 // Due to this pattern it's possible for the destructor of the value in
310 // `ptr` (e.g. if this is being recursively initialized) to re-access
311 // TLS, in which case there will be a `&` and `&mut` pointer to the same
312 // value (an aliasing violation). To avoid setting the "I'm running a
313 // destructor" flag we just use `mem::replace` which should sequence the
314 // operations a little differently and make this safe to call.
315 mem::replace(&mut *ptr, Some(value));
317 (*ptr).as_ref().unwrap()
320 /// Query the current state of this key.
322 /// A key is initially in the `Uninitialized` state whenever a thread
323 /// starts. It will remain in this state up until the first call to [`with`]
324 /// within a thread has run the initialization expression successfully.
326 /// Once the initialization expression succeeds, the key transitions to the
327 /// `Valid` state which will guarantee that future calls to [`with`] will
328 /// succeed within the thread.
330 /// When a thread exits, each key will be destroyed in turn, and as keys are
331 /// destroyed they will enter the `Destroyed` state just before the
332 /// destructor starts to run. Keys may remain in the `Destroyed` state after
333 /// destruction has completed. Keys without destructors (e.g. with types
334 /// that are [`Copy`]), may never enter the `Destroyed` state.
336 /// Keys in the `Uninitialized` state can be accessed so long as the
337 /// initialization does not panic. Keys in the `Valid` state are guaranteed
338 /// to be able to be accessed. Keys in the `Destroyed` state will panic on
339 /// any call to [`with`].
341 /// [`with`]: ../../std/thread/struct.LocalKey.html#method.with
342 /// [`Copy`]: ../../std/marker/trait.Copy.html
343 #[unstable(feature = "thread_local_state",
344 reason = "state querying was recently added",
346 pub fn state(&'static self) -> LocalKeyState {
348 match (self.inner)() {
351 Some(..) => LocalKeyState::Valid,
352 None => LocalKeyState::Uninitialized,
355 None => LocalKeyState::Destroyed,
360 /// Acquires a reference to the value in this TLS key.
362 /// This will lazily initialize the value if this thread has not referenced
363 /// this key yet. If the key has been destroyed (which may happen if this is called
364 /// in a destructor), this function will return a ThreadLocalError.
368 /// This function will still `panic!()` if the key is uninitialized and the
369 /// key's initializer panics.
370 #[unstable(feature = "thread_local_state",
371 reason = "state querying was recently added",
373 pub fn try_with<F, R>(&'static self, f: F) -> Result<R, AccessError>
374 where F: FnOnce(&T) -> R {
376 let slot = (self.inner)().ok_or(AccessError {
379 Ok(f(match *slot.get() {
380 Some(ref inner) => inner,
381 None => self.init(slot),
388 #[cfg(target_thread_local)]
390 use cell::{Cell, UnsafeCell};
394 use sys::fast_thread_local::{register_dtor, requires_move_before_drop};
397 inner: UnsafeCell<Option<T>>,
399 // Metadata to keep track of the state of the destructor. Remember that
400 // these variables are thread-local, not global.
401 dtor_registered: Cell<bool>,
402 dtor_running: Cell<bool>,
405 impl<T> fmt::Debug for Key<T> {
406 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
412 pub const fn new() -> Key<T> {
414 inner: UnsafeCell::new(None),
415 dtor_registered: Cell::new(false),
416 dtor_running: Cell::new(false)
420 pub unsafe fn get(&self) -> Option<&'static UnsafeCell<Option<T>>> {
421 if mem::needs_drop::<T>() && self.dtor_running.get() {
424 self.register_dtor();
425 Some(&*(&self.inner as *const _))
428 unsafe fn register_dtor(&self) {
429 if !mem::needs_drop::<T>() || self.dtor_registered.get() {
433 register_dtor(self as *const _ as *mut u8,
435 self.dtor_registered.set(true);
439 unsafe extern fn destroy_value<T>(ptr: *mut u8) {
440 let ptr = ptr as *mut Key<T>;
441 // Right before we run the user destructor be sure to flag the
442 // destructor as running for this thread so calls to `get` will return
444 (*ptr).dtor_running.set(true);
446 // Some implementations may require us to move the value before we drop
447 // it as it could get re-initialized in-place during destruction.
449 // Hence, we use `ptr::read` on those platforms (to move to a "safe"
450 // location) instead of drop_in_place.
451 if requires_move_before_drop() {
452 ptr::read((*ptr).inner.get());
454 ptr::drop_in_place((*ptr).inner.get());
461 use cell::{Cell, UnsafeCell};
465 use sys_common::thread_local::StaticKey as OsStaticKey;
468 // OS-TLS key that we'll use to key off.
470 marker: marker::PhantomData<Cell<T>>,
473 impl<T> fmt::Debug for Key<T> {
474 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
479 unsafe impl<T> ::marker::Sync for Key<T> { }
481 struct Value<T: 'static> {
482 key: &'static Key<T>,
483 value: UnsafeCell<Option<T>>,
486 impl<T: 'static> Key<T> {
487 pub const fn new() -> Key<T> {
489 os: OsStaticKey::new(Some(destroy_value::<T>)),
490 marker: marker::PhantomData
494 pub unsafe fn get(&'static self) -> Option<&'static UnsafeCell<Option<T>>> {
495 let ptr = self.os.get() as *mut Value<T>;
497 if ptr as usize == 1 {
500 return Some(&(*ptr).value);
503 // If the lookup returned null, we haven't initialized our own
504 // local copy, so do that now.
505 let ptr: Box<Value<T>> = box Value {
507 value: UnsafeCell::new(None),
509 let ptr = Box::into_raw(ptr);
510 self.os.set(ptr as *mut u8);
515 unsafe extern fn destroy_value<T: 'static>(ptr: *mut u8) {
516 // The OS TLS ensures that this key contains a NULL value when this
517 // destructor starts to run. We set it back to a sentinel value of 1 to
518 // ensure that any future calls to `get` for this thread will return
521 // Note that to prevent an infinite loop we reset it back to null right
522 // before we return from the destructor ourselves.
523 let ptr = Box::from_raw(ptr as *mut Value<T>);
525 key.os.set(1 as *mut u8);
527 key.os.set(ptr::null_mut());
531 #[cfg(all(test, not(target_os = "emscripten")))]
533 use sync::mpsc::{channel, Sender};
534 use cell::{Cell, UnsafeCell};
535 use super::LocalKeyState;
538 struct Foo(Sender<()>);
542 let Foo(ref s) = *self;
549 thread_local!(static FOO: Cell<i32> = Cell::new(1));
552 assert_eq!(f.get(), 1);
555 let (tx, rx) = channel();
556 let _t = thread::spawn(move|| {
558 assert_eq!(f.get(), 1);
560 tx.send(()).unwrap();
565 assert_eq!(f.get(), 2);
574 assert!(FOO.state() == LocalKeyState::Destroyed);
578 assert!(FOO.state() == LocalKeyState::Uninitialized);
581 thread_local!(static FOO: Foo = foo());
584 assert!(FOO.state() == LocalKeyState::Uninitialized);
586 assert!(FOO.state() == LocalKeyState::Valid);
588 assert!(FOO.state() == LocalKeyState::Valid);
589 }).join().ok().unwrap();
594 thread_local!(static FOO: UnsafeCell<Option<Foo>> = UnsafeCell::new(None));
596 let (tx, rx) = channel();
597 let _t = thread::spawn(move|| unsafe {
598 let mut tx = Some(tx);
600 *f.get() = Some(Foo(tx.take().unwrap()));
610 thread_local!(static K1: UnsafeCell<Option<S1>> = UnsafeCell::new(None));
611 thread_local!(static K2: UnsafeCell<Option<S2>> = UnsafeCell::new(None));
612 static mut HITS: u32 = 0;
618 if K2.state() == LocalKeyState::Destroyed {
622 K2.with(|s| *s.get() = Some(S2));
634 assert!(K1.state() != LocalKeyState::Destroyed);
636 K1.with(|s| *s.get() = Some(S1));
641 thread::spawn(move|| {
643 }).join().ok().unwrap();
647 fn self_referential() {
649 thread_local!(static K1: UnsafeCell<Option<S1>> = UnsafeCell::new(None));
653 assert!(K1.state() == LocalKeyState::Destroyed);
657 thread::spawn(move|| unsafe {
658 K1.with(|s| *s.get() = Some(S1));
659 }).join().ok().unwrap();
662 // Note that this test will deadlock if TLS destructors aren't run (this
663 // requires the destructor to be run to pass the test). macOS has a known bug
664 // where dtors-in-dtors may cancel other destructors, so we just ignore this
667 #[cfg_attr(target_os = "macos", ignore)]
668 fn dtors_in_dtors_in_dtors() {
669 struct S1(Sender<()>);
670 thread_local!(static K1: UnsafeCell<Option<S1>> = UnsafeCell::new(None));
671 thread_local!(static K2: UnsafeCell<Option<Foo>> = UnsafeCell::new(None));
675 let S1(ref tx) = *self;
677 if K2.state() != LocalKeyState::Destroyed {
678 K2.with(|s| *s.get() = Some(Foo(tx.clone())));
684 let (tx, rx) = channel();
685 let _t = thread::spawn(move|| unsafe {
686 let mut tx = Some(tx);
687 K1.with(|s| *s.get() = Some(S1(tx.take().unwrap())));
696 use collections::HashMap;
700 fn square(i: i32) -> i32 { i * i }
701 thread_local!(static FOO: i32 = square(3));
710 fn map() -> RefCell<HashMap<i32, i32>> {
711 let mut m = HashMap::new();
715 thread_local!(static FOO: RefCell<HashMap<i32, i32>> = map());
718 assert_eq!(map.borrow()[&1], 2);
724 thread_local!(static FOO: RefCell<Vec<u32>> = RefCell::new(vec![1, 2, 3]));
727 assert_eq!(vec.borrow().len(), 3);
728 vec.borrow_mut().push(4);
729 assert_eq!(vec.borrow()[3], 4);