C++中多线程间共享数据详解

std::list<int> some_list;
std::mutex some_mutex;

void add_to_list(int new_value){
    std::lock_guard<std::mutex> guard(some_mutex);
	some_list.push_back(new_value);
}

bool list_contains(int value_to_find){
    std::lock_guard<std::mutex> guard(some_mutex);
    return std::find(some_list.begin(), some_list.end(), value_to_find) != some_list.end();
}

class some_big_object;
void swap(some_big_object& lhs, some_big_object& rhs);

class X{
private:
	some_big_object some_detail;
	std::mutex m;

public:
	X(const some_big_object &sd):some_detail(sd){}

	friend void swap(X& lhs, X& rhs){
        if(&lhs == &rhs){
            return;
        }

        std::lock(lhs.m, rhs.m);
        std::lock_guard lock_a(lhs.m, std::adopt_lock);
        std::lock_guard lock_b(rhs.m, std::adopt_lock);

        swap(lhs.some_detail, rhs.some_detail);
    }
}

void swap(X& lhs, X& rhs){
    if(&lhs == &rhs){
            return;
    }

    std::scoped_lock guard(lhs.m, rhs.m);
    swap(lhs.some_detail, rhs.some_detail);
}

void undefined_behaviour_with_double_checked_locking()
{
    if(!resource_ptr){ //①
        std::lock_guard<std::mutex> lk(resource_mutex); // ②
        if(!resource_ptr){
            resource_ptr.reset(new some_resource);
        }
    }
    resource_ptr->do_something();
}

std::shared_ptr<some_resource> resource_ptr;
std::once_flag resource_flag;

void init_resource()
{
    resource_ptr.reset(new some_resource);
}

void foo()
{
    std::call_once(resource_flag, init_resource);
    resource_ptr->do_something();
}

std::shared_mutex mutex;

// 获取读锁（又叫共享锁）
std::shared_lock read_lock(mutex);

// 获取写锁（又叫排它锁）
std::lock_guard write_lock(mutex);