Thread-local storage duration is a term used to refer to data that is seemingly global or static storage duration (from the viewpoint of the functions using it) but, in actual fact, there is one copy per thread.
It adds to the current options:
- automatic (exists during a block or function);
- static (exists for the program duration); and
- dynamic (exists on the heap between allocation and deallocation).
Something that is thread-local is brought into existence at thread creation time and disposed of when the thread finishes.
For example, think of a random number generator where the seed must be maintained on a per-thread basis. Using a thread-local seed means that each thread gets its own random number sequence, independent of all other threads.
If your seed was a local variable within the random function, it would be initialised every time you called it, giving you the same number each time. If it was a global, threads would interfere with each other’s sequences.
Another example is something like strtok
where the tokenisation state is stored on a thread-specific basis. That way, a single thread can be sure that other threads won’t screw up its tokenisation efforts, while still being able to maintain state over multiple calls to strtok
– this basically renders strtok_r
(the thread-safe version) redundant.
Yet another example would be something like errno
. You don’t want separate threads modifying errno
after one of your calls fails, but before you’ve had a chance to check the result.
This site has a reasonable description of the different storage duration specifiers.