C++并发编程实战 #2 在线程间共享数据

用互斥保护数据

在C++中，通过构造mutex的实例来创建互斥，调用成员函数lock()对其进行加锁，调用unlock()进行解锁。

不推荐直接使用成员函数进行加锁和解锁，因为若按此处理，则在函数的每条代码路径上都要调用unlock()，包括由于异常导致退出的路径。

因此，使用lock_guard<>来进行加锁和解锁。其在构造时给互斥加锁，在析构时解锁，从而保证互斥总被正确解锁。

int a = 0;
mutex m;

void func() {
    lock_guard<mutex> guard(m);
    for (int i = 0; i < 10000; i++)
        a++;
}

void otherfunc() {
    lock_guard<mutex> guard(m);
    for (int i = 0; i < 10000; i++)
        a++;
}

int main()
{
    
    cout << a << endl;
    thread t1(func);
    thread t2(otherfunc);
    t1.join();
    t2.join();

    cout << a << endl;

    
    return 0;
}

指针或引用会造成互斥保护失效

class some_data{
    int a;
    string b;
public:
    void do_sth();
};

class data_wrapper{
    some_data data;
    mutex m;
public:
    template<typename Function>
    void process_data(Function func){
        lock_guard<mutex> l(m);
        func(data);
    }
};

some_data* unprotected;

void malicious_function(some_data& protected_data){
    unprotected = &protected_data;
}

data_wrapper x;

void foo(){
    x.process_data(malicious_function);
    unprotected->do_sth();
}

在上面的例子中，process_data()函数内用lock_guard保护了数据的共享。但是，其参数是使用者提供的函数。

在foo()中，传入malicious_function，绕过了保护，直接调用了do_sth。

对于这种问题，C++线程库没有处理的方法，只有靠开发者正确的锁定互斥。

不得向锁所在的作用域之外传递指针和引用，指向受保护的数据。无论是通过函数返回值将它们保存到对外可见的内存，还是将它们作为参数传递给使用者提供的函数。

接口固有的条件竞争

在涉及到接口的情况下，有可能遇到条件竞争。如果多线程对同一个栈数据结构使用互斥进行数据读写操作，在线程调用empty()或size()时，返回值可能是正确的，但是一旦函数返回，其他线程不再受限，那么就能自由的访问栈容器，可能会有其他数据出栈或入栈，令前面的线程得到的结果失效。

stack<int> s;
if(!s.empty()){
    int value = s.top();
    s.pop();
    do_sth(value);
}

在empty与top()中间，可能会有其他线程调用pop()。这是典型的条件竞争，根本原因在于函数接口，即使在内部使用互斥保护栈容器中的元素，也无法防范。

需要将接口函数定义为线程安全的，例如重写一个线程安全的threadsafe_stack类。