Thread-local storage

suggest change

Thread-local storage can be created using the thread_local keyword. A variable declared with the thread_local specifier is said to have thread storage duration.

Each thread in a program has its own copy of each thread-local variable.
A thread-local variable with function (local) scope will be initialized the first time control passes through its definition. Such a variable is implicitly static, unless declared extern.
A thread-local variable with namespace or class (non-local) scope will be initialized as part of thread startup.
Thread-local variables are destroyed upon thread termination.
A member of a class can only be thread-local if it is static. There will therefore be one copy of that variable per thread, rather than one copy per (thread, instance) pair.

Example:

void debug_counter() {
    thread_local int count = 0;
    Logger::log("This function has been called %d times by this thread", ++count);
}

Found a mistake? Have a question or improvement idea? Let me know.

Threading/

Threading

Creating a std::thread

Passing a reference to a thread

Using std::async instead of std::thread

Create a simple thread pool

Ensuring a thread is always joined

Basic Synchronization

Using Condition Variables

Operations on the current thread

Thread operations

Thread-local storage

Reassigning thread objects

Table Of Contents

1 Getting started

2 Literals

3 Basic type keywords

4 Operator precedence

5 Floating point arithmetic

6 Bit operators

7 Bit manipulation

8 Bit fields

9 Arrays

10 Flow control

11 const keyword

12 Loops

13 mutable keyword

14 friend keyword

15 keywords

16 Variable declaration keywords

17 auto keyword

18 Pointers

19 Type keywords (class, enum, struct, union)

20 Classes / structs

21 std::string

22 Enumeration

23 std::atomic<T>

24 std::vector

25 std::array

26 std::pair

27 std::map

28 std::unordered_map

29 std::set and std::multiset

30 std::any

31 std::variant

32 std::optional

33 std::integer_sequence

34 std::function

35 std::forward_list

36 std::iomanip

37 Iterators

38 Basic I/O

39 File I/O

40 Streams

41 Stream manipulators

42 Metaprogramming

43 Returning multiple values from a function

44 References

45 Polymorphism

46 Value and reference semantics

47 Function call by value vs. by reference

48 Copying vs assignment

49 Pointers to class / struct members

50 The this pointer

51 Smart pointers

52 Unions

53 Templates

54 Namespaces

55 Function overloading

56 Operator overloading

57 Lambdas

58 Threading

59 Value categories

60 Preprocessor

61 SFINAE

62 Rule of three, five and zero

63 RAII

64 Exceptions

65 Implementation-defined behavior

66 Special member functions

67 Random numbers

68 Sorting

69 Regular expressions

70 Perfect forwarding

71 Virtual member functions

72 Undefined behavior

73 Overload resolution

74 Move semantics

75 Pimpl idiom

76 Copy elision

77 Fold expressions

78 Unnamed types

79 Singleton

80 ISO C++ Standard

81 User-defined literals

82 Type erasure

83 Memory management

84 Explicit type conversions

85 RTTI

86 Standard library algorithms

87 Expression templates

88 Scopes

89 Atomic types

90 static assert

91 constexpr

92 Date and time with std::chrono

93 Trailing return type

94 Function template overloading

95 Common compile linker errors

96 Design patterns

97 Optimizations

98 Compiling and building

99 Type traits

100 One definition rule

101 Unspecified behavio

102 Argument dependent name lookup

103 Attributes

104 Internationalization

105 Profiling

106 Return type covariance

107 Non-static member functions

108 Recursion

109 Callable objects

110 Constant class member functions

111 C++ vs. C++ 11 vs C++ 17

112 Inline functions

113 Client server examples

114 Header files

115 Const correctness

116 Refactoring techniques

117 Parameter packs

118 Iteration

119 type deduction

120 C++ 11 memory model

121 Build systems

122 Concurrency with OpenMP

123 Type inference

124 Resource management

125 Storage class specifiers

126 Alignment

127 Inline variables

128 Linkage specifications

129 Curiusly recurring template pattern

130 Using declaration

131 Typedef and type aliases

132 Layout of object types

133 C incompatibilities

134 Optimization

135 Semaphore

136 Thread synchronization

137 Debugging

138 Futures and promises

139 More undefined behaviors

140 Mutexes

141 Recursive mutex

142 Unit testing

143 decltype

144 Digit separators

145 C++ Containers

146 Arithmetic meta-programming

147 Contributors