What are the precautions for using C++ templates in multi-threaded programming?

Notes when using templates in C++ multi-threaded programming: Avoid modifying thread-private data of template class member functions. Store template class objects in a thread-safe container. Avoid using mutable static variables in template classes. Use appropriate synchronization mechanisms (such as mutex locks) to protect data.

Notes on C++ templates in multi-threaded programming

C++ templates are a powerful feature that allows us to use Write code based on it. However, there are some things to note when using templates in multi-threaded programming to avoid data races and deadlock issues.

1. Avoid modifying thread private data of template class member functions

For thread private data, we should use the thread_local keyword to declare. For non-static member functions, modifications to thread-private data in the template class may cause different threads to see inconsistent data.

class MyClass {
public:
    thread_local int x;

    void modifyX() {
        ++x; // 可能导致数据竞争
    }
};

2. Store template class objects in thread-safe containers

In a multi-threaded environment, thread-safe containers should be used, such as std::vector andstd::map. If a template class object is stored in a non-thread-safe container, such as std::list, data corruption or deadlock may result.

std::vector<MyClass> objects; // 线程安全

std::list<MyClass> objects; // 非线程安全，可能导致数据损坏或死锁

3. Avoid using mutable static variables in template classes

Variable static variables are dangerous in a multi-threaded environment because they may be accessed by multiple threads at the same time. When using mutable static variables in template classes, extreme care should be taken and appropriate synchronization mechanisms should be used to avoid data races.

template <typename T>
class MyClass {
public:
    static int x; // 可变静态变量，可能导致数据竞争

    static void modifyX() {
        ++x; // 可能导致数据竞争
    }
};

4. Use appropriate synchronization mechanisms to protect data

In order to avoid data races, when using template classes in a multi-threaded environment, appropriate synchronization mechanisms should be used, such as mutex locks, Condition variables or spin locks.

std::mutex m;

template <typename T>
class MyClass {
public:
    void modifyX() {
        std::lock_guard<std::mutex> lock(m);
        ++x; // 受互斥锁保护
    }
};

Practical case

In the following code example, we demonstrate how to safely use C++ templates in multi-threaded programs:

#include <iostream>
#include <thread>
#include <vector>

template <typename T>
class Counter {
private:
    std::mutex m;
    T count;

public:
    Counter() : count(0) {}

    void increment() {
        std::lock_guard<std::mutex> lock(m);
        ++count;
    }

    T get() const {
        std::lock_guard<std::mutex> lock(m);
        return count;
    }
};

int main() {
    // 创建一个`Counter`模板类的对象
    Counter<int> counter;

    // 创建多个线程并并发增加计数器
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back([&counter] {
            for (int j = 0; j < 10000; ++j) {
                counter.increment();
            }
        });
    }

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

    // 输出计数器的最终值
    std::cout << counter.get() << std::endl;

    return 0;
}

Output result: 100000, proved Thread safety of template classes when used in multi-threaded environments.

The above is the detailed content of What are the precautions for using C++ templates in multi-threaded programming?. For more information, please follow other related articles on the PHP Chinese website!