C++ Concurrent Programming: How to utilize thread-local storage?

Thread-local storage (TLS) in C provides a mechanism to maintain private data for each thread in a multi-threaded environment, ensuring that even if multiple threads access the variable at the same time, they do not interfere with each other. By declaring a local variable using the thread_local keyword, a separate instance of the variable is created in each thread, ensuring data isolation. This mechanism can be used to maintain thread-specific counters, status flags, and other private data, avoiding data race problems in multi-threaded programming.

C Concurrent Programming: Utilizing Thread Local Storage

Thread local storage (TLS) is a method used in multi-threaded environments A mechanism for maintaining each thread's private data. In C, TLS can be implemented via the thread_local keyword.

Principle of action

thread_local The declaration is used to declare a local variable that has a separate instance in each thread. When the variable is accessed, the compiler will generate a thread-specific storage location and the variable's value will be stored only in that location. This ensures that even if multiple threads from different threads are accessing the variable at the same time, they do not interfere with each other.

Grammar

The syntax is as follows:

thread_local <type> variable;

Among them:

• type is a variable type.
• variable is the name of the variable.

Practical Case

Let’s look at an example of using TLS to calculate a global counter in a multi-threaded application:

// 定义一个全局计数器变量，没有任何线程安全保护
int global_counter = 0;

// 定义一个线程局部计数器变量
thread_local int thread_local_counter = 0;

// 执行增加计数器的线程函数
void increment_counter() {
  // 增加全局计数器
  global_counter++;

  // 增加线程局部计数器
  thread_local_counter++;
}

int main() {
  // 创建多个线程
  std::vector<std::thread> threads;
  for (int i = 0; i < 10; i++) {
    threads.push_back(std::thread(increment_counter));
  }

  // 等待所有线程完成
  for (auto& thread : threads) {
    thread.join();
  }

  // 输出结果
  std::cout << "Global counter: " << global_counter << std::endl; // 可能不是预期的值
  std::cout << "Thread local counter: " << thread_local_counter << std::endl; // 将输出每个线程的局部计数器值
}

In this In the example, global_counter may have concurrent access issues, leading to inaccurate results. And thread_local_counter ensures that each thread has a separate counter instance, and there will be no data competition issues.

The above is the detailed content of C++ Concurrent Programming: How to utilize thread-local storage?. For more information, please follow other related articles on the PHP Chinese website!