thread_lock

锁
mutable std::shared_mutex m_mutex
是一个同步原语，用于保护共享数据不被多个线程同时访问
1，(shared)多个线程共享同一个互斥体的所有权
2，(exclusive)只有一个线程可以拥有互斥锁
如果一个线程已经获得了独占锁（通过lock，try_lock），其他线程就无法获得这把锁（包括共享锁）。
如果一个线程已经获取了共享锁（通过lock_shared、try_lock_shared），其他线程就无法获取排它锁，但可以获取共享锁。
只有当独占锁还没有被任何线程获取到时，共享锁才能被多个线程获取到。
在一个线程内，同一时间只能获取一把锁（共享锁或独占锁）。
当共享数据可以被任意数量的线程同时安全地读取时，共享互斥体特别有用，但一个线程只能在没有其他线程同时读取或写入时写入相同的数据。
example

#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <syncstream>
#include <thread>
 
class ThreadSafeCounter
{
public:
    ThreadSafeCounter() = default;
 
    // Multiple threads/readers can read the counter's value at the same time.
    unsigned int get() const
    {
        std::shared_lock lock(mutex_);
        return value_;
    }
 
    // Only one thread/writer can increment/write the counter's value.
    void increment()
    {
        std::unique_lock lock(mutex_);
        ++value_;
    }
 
    // Only one thread/writer can reset/write the counter's value.
    void reset()
    {
        std::unique_lock lock(mutex_);
        value_ = 0;
    }
 
private:
    mutable std::shared_mutex mutex_;
    unsigned int value_{};
};
 
int main()
{
    ThreadSafeCounter counter;
 
    auto increment_and_print = [&counter]()
    {
        for (int i{}; i != 3; ++i)
        {
            counter.increment();
            std::osyncstream(std::cout)
                << std::this_thread::get_id() << ' ' << counter.get() << '\n';
        }
    };
 
    std::thread thread1(increment_and_print);
    std::thread thread2(increment_and_print);
 
    thread1.join();
    thread2.join();
}

读锁用share_lock
写锁用lock_guard

lambda
匿名函数和for_each结合做修改数组

for_each(lstInt.begin(), lstInt.end(), [](int& i){
	if (i < 0)
		i = -i;
});