GeezerVison

In C11, the keyword _Thread_local is used for defining thread-local variables. The header <threads.h>, if supported, defines thread_local as a synonym for that keyword.

In C11, <threads.h> also defines a number of functions for retrieving, changing, and destructing a thread-local storage, using names starting with tss_. In C23, thread_local itself becomes a keyword.^[2]

thread_local int foo = 0;

C++11 introduces the thread_local^[3] keyword, which can be used in the following cases:

• Namespace-level (global) variables
• File static variables
• Function static variables
• Static member variables

Aside from that, various compiler implementations provide specific ways to declare thread-local variables:

• Solaris Studio C/C++,^[4] IBM XL C/C++,^[5] GNU C,^[6] llvm-gcc,^[7] Clang,^[8] and Intel C++ Compiler (Linux systems)^[9] use the syntax:

  __thread int number;

• Visual C++,^[10] Intel C/C++ (Windows systems),^[11] C++Builder, Clang,^[12] and Digital Mars C++ use the syntax:

  __declspec(thread) int number;

• C++Builder also supports the syntax:

  int __thread number;

On Windows versions before Vista and Server 2008, __declspec(thread) works in DLLs only when those DLLs are bound to the executable, and will not work for those loaded with LoadLibrary() (a protection fault or data corruption may occur).^[10]

Common Lisp provides a feature called dynamically scoped variables.

Dynamic variables have a binding, which is private to the invocation of a function and all of the children called by that function.

This abstraction naturally maps to thread-specific storage, and Lisp implementations that provide threads do this. Common Lisp has numerous standard dynamic variables, and so threads cannot be sensibly added to an implementation of the language without these variables having thread-local semantics in dynamic binding.

For instance, the standard variable *print-base* determines the default radix in which integers are printed. If this variable is overridden, then until the override ends, code will print integers in an alternate radix:

;;; function foo and its children will print
;; in hexadecimal:
(let ((*print-base* 16)) (foo))

If functions can execute concurrently on different threads, this binding has to be properly thread-local; otherwise, each thread will fight over who controls a global printing radix.

In D version 2, all static and global variables are thread-local by default and are declared with syntax similar to "normal" global and static variables in other languages. Global variables must be explicitly requested using the shared keyword:

int threadLocal; // This is a thread-local variable.
shared int global; // This is a global variable shared with all threads.

The shared keyword works both as the storage class, and as a type qualifier – shared variables are subject to some restrictions which statically enforce data integrity.^[13] To declare a "classic" global variable without these restrictions, the unsafe __gshared keyword must be used:^[14]

__gshared int global;  // This is a plain old global variable.

In Java, thread-local variables are implemented by the java.lang.ThreadLocal class object.^[15] The T object inside java.lang.ThreadLocal<T> is accessed via get() and set(), and a remove() method which removes the current thread's value for the thread-local variable.^[15] Thread-local variables are typically private for strict encapsulation and static to maintain separate state per thread.

For example, a thread-local variable holding an integer looks like this (with no initial value):

private static final ThreadLocal<Integer> i = new ThreadLocal<>();

To assign an initial value, the factory method ThreadLocal.withInitial() can be used with a lambda:

private static final ThreadLocal<Integer> i = ThreadLocal.withInitial(() -> 0);

Otherwise, if not using lambdas, to assign an initial value, the ThreadLocal.initialValue() method must be overriden with an anonymous class:

// Note that, prior to Java 9, an anonymous class cannot infer generics;
// the full generic must be spelled out (new ThreadLocal<Integer>() {}) 
private static final ThreadLocal<Integer> i = new ThreadLocal<>() {
    @Override
    protected Integer initialValue() {
        return 0;
    }
}

At least for Oracle/OpenJDK, this does not use native thread-local storage in spite of OS threads being used for other aspects of Java threading. Instead, each java.lang.Thread object stores a (non-thread-safe) map of java.lang.ThreadLocal objects to their values (as opposed to each java.lang.ThreadLocal having a map of java.lang.Thread objects to values and incurring a performance overhead).^[16]

In .NET Framework languages such as C#, static fields can be marked with the ThreadStatic attribute:^[17]: 898

using System;

class FooBar
{
    [ThreadStatic]
    private static int _foo;
}

In .NET Framework 4.0 the System.Threading.ThreadLocal<T> class is available for allocating and lazily loading thread-local variables.^[17]: 899

using System.Threading;

class FooBar
{
    private static ThreadLocal<int> _foo;
}

System.Threading.Thread provides an API through the Thread.GetNamedDataSlot() method for dynamically allocating thread-local variables, which looks up a named data slot and returns a System.LocalDataStoreSlot.^{[17]: 899–890}

In Object Pascal (Delphi) or Free Pascal the threadvar reserved keyword can be used instead of 'var' to declare variables using the thread-local storage.

var
   mydata_process: integer;
threadvar
   mydata_threadlocal: integer;

In Cocoa, GNUstep, and OpenStep, each NSThread object has a thread-local dictionary that can be accessed through the thread's threadDictionary method.

NSMutableDictionary *dict = [[NSThread currentThread] threadDictionary];
dict[@"A key"] = @"Some data";

In Perl threads were added late in the evolution of the language, after a large body of extant code was already present on the Comprehensive Perl Archive Network (CPAN). Thus, threads in Perl by default take their own local storage for all variables, to minimise the impact of threads on extant non-thread-aware code. In Perl, a thread-shared variable can be created using an attribute:

use threads;
use threads::shared;

my $localvar;
my $sharedvar :shared;

In PureBasic thread variables are declared with the keyword Threaded.

Threaded Var

In Python version 2.4 or later, the threading.local class can be used to create thread-local storage.

import threading

mydata = threading.local()
mydata.x = 1

Multiple instances of threading.local can be created to store different sets of variables.^[18] Thus, it is not a singleton.

Since Python 3.7, the contextvars module provides generic thread-local storage.

from contextvars import ContextVar

user_id: ContextVar[int] = ContextVar("user_id")
request_id = ContextVar[str] = ContextVar("request_id")

user_id.set(42)
request_id.set("abc-123")

current_user: int = user_id.get()

Ruby can create/access thread-local variables using []=/[] methods:

Thread.current[:user_id] = 1

Thread-local variables can be created in Rust using the thread_local! macro provided by the Rust standard library:

use std::cell::RefCell;
use std::thread;

thread_local!(static FOO: RefCell<u32> = RefCell::new(1));

FOO.with(|f| {
    assert_eq!(*f.borrow(), 1);
    *f.borrow_mut() = 2;
});

// each thread starts out with the initial value of 1, even though this thread already changed its copy of the thread local value to 2
let t = thread::spawn(move || {
    FOO.with(|f| {
        assert_eq!(*f.borrow(), 1);
        *f.borrow_mut() = 3;
    });
});

// wait for the thread to complete and bail out on panic
t.join().unwrap();

// original thread retains the original value of 2 despite the child thread changing the value to 3 for that thread
FOO.with(|f| {
    assert_eq!(*f.borrow(), 2);
});