What does the thread_local mean in C++11?

by

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 automatic (exists during a block/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 and disposed of when the thread stops.

Some examples follow.

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 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.

Both these examples allow for the thread local variable to exist within the function that uses it. In pre-threaded code, it would simply be a static storage duration variable within the function. For threads, that’s modified to thread local storage duration.

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 can check the variable, and yet you only want one copy per thread.

This site has a reasonable description of the different storage duration specifiers.

More Related Contents:

  1. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  2. Concurrency: Atomic and volatile in C++11 memory model
  3. What happens to a detached thread when main() exits?
  4. What are the correct link options to use std::thread in GCC under linux?
  5. Why is the destructor of a future returned from `std::async` blocking?
  6. How to check if a std::thread is still running?
  7. Does MinGW-w64 support std::thread out of the box when using the Win32 threading model?
  8. C++11 thread-safe queue
  9. What exactly is std::atomic?
  10. How to implement multithread safe singleton in C++11 without using
  11. Difference between pointer and reference as thread parameter
  12. std::unique_lock or std::lock_guard?
  13. Does the C++ volatile keyword introduce a memory fence?
  14. Which std::async implementations use thread pools?
  15. How can I use something like std::vector?
  16. Are C++11 thread_local variables automatically static?
  17. Get the status of a std::future
  18. Delayed start of a thread in C++ 11
  19. What is std::promise?
  20. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  21. C++11 STL containers and thread safety
  22. Can I use std::async without waiting for the future limitation?
  23. Passing arguments to std::async by reference fails
  24. C++ terminate called without an active exception
  25. C++11 std::threads vs posix threads
  26. Understanding std::atomic::compare_exchange_weak() in C++11
  27. Double-Checked Lock Singleton in C++11
  28. std::thread calling method of class [duplicate]
  29. Write concurrently vector
  30. About thread-safety of weak_ptr

Leave a Comment