Strategies for using default parameters and variable parameters of C++ functions in multi-threaded environments

When using default parameters and variable parameters of C functions in a multi-threaded environment, be sure to consider thread safety issues. Default parameters: If default parameters are immutable (such as integers or string literals), they are thread-safe because they cannot be modified. Variable parameters: Variable parameters can be copied to thread local storage, and each thread has an independent copy to avoid data races.

Usage strategy of default parameters and variable parameters of C function in multi-threaded environment

Used in multi-threaded environment When using default parameters and variable parameters of C functions, thread safety issues need to be considered. This is because both default parameters and variadic parameters are stored in the function stack frame, and if multiple threads call the same function at the same time, they may use the same memory space, causing data races.

Thread-safe use of default parameters

Default parameters are initialized when the function is defined and stored in a known location in the function stack frame. Therefore, if default parameters are immutable (such as integers or string literals), they are thread-safe because they cannot be modified.

int sum(int a, int b = 0) {
  return a + b;
}

In the above example, b is an immutable default parameter and therefore safe to use in a multi-threaded environment.

Thread-safe use of variable parameters

Variable parameters are stored in the dynamically allocated memory area of ​​the function stack frame. If multiple threads call a function with variadic arguments simultaneously, they may use the same memory space, causing a data race.

To solve this problem, the variable parameters can be copied to thread local storage. Thread local storage is a special area of ​​memory managed by the compiler, and each thread has its own copy.

#include <thread>
#include <vector>

void sum_array(std::vector<int>& data) {
  int sum = 0;
  for (int x : data) {
    sum += x;
  }
  printf("Sum: %d\n", sum);
}

int main() {
  std::vector<int> data = {1, 2, 3, 4, 5};
  std::vector<std::thread> threads;

  for (int i = 0; i < 4; i++) {
    threads.emplace_back(sum_array, data);  // 每个线程拥有自己的 data 副本
  }

  for (auto& t : threads) {
    t.join();
  }

  return 0;
}

In this example, data is a variadic parameter that is copied to each thread's thread-local storage. This ensures that each thread has its own independent copy of data, thus avoiding data races.

The above is the detailed content of Strategies for using default parameters and variable parameters of C++ functions in multi-threaded environments. For more information, please follow other related articles on the PHP Chinese website!