Is there a difference between these two code segments:
void f() {
thread_local vector<int> V;
V.clear();
... // use V as a temporary variable
}
and
void f() {
static thread_local vector<int> V;
V.clear();
... // use V as a temporary variable
}
Backstory: originally I had a STATIC vector V (for holding some intermediate values, it gets cleared every time I enter the function) and a single-threaded program. I want to turn the program into a multithreading one, so somehow I have to get rid of this static modifier. My idea is to turn every static into thread_local and not worry about anything else? Can this approach backfire?
According to the C++ Standard
When thread_local is applied to a variable of block scope the storage-class-specifier static is implied if it does not appear explicitly
So it means that this definition
void f() {
thread_local vector<int> V;
V.clear();
... // use V as a temporary variable
}
is equivalent to
void f() {
static thread_local vector<int> V;
V.clear();
... // use V as a temporary variable
}
However, a static variable is not the same as a thread_local variable.
1 All variables declared with the thread_local keyword have thread storage duration. The storage for these entities shall last for the duration of the thread in which they are created. There is a distinct object or reference per thread, and use of the declared name refers to the entity associated with the current thread
To distinguish these variables the standard introduces a new term thread storage duration along with static storage duration.