c++11中的线程、锁和条件变量

void func(int& a)
{
    a++;
}

int main()
{
    int a = 42;
    
    thread t(func, ref(a));
    t.join();

    cout << a << endl;

    system("pause");
    return 0;
}
//输出43，如果不用ref，运行出错,why?

//在thread的构造函数中，线程函数的参数被拷贝(浅拷贝)到线程独立内存中，这样可以被线程对象访问，即使函数形参是引用
//线程构造函数拷贝data，传递给函数的参数是data拷贝的引用，而非数据本身的引用，若用ref封装data,则update函数就会
//接收到data变量的引用，而非data拷贝的引用
struct widget
{
    int a;
    string s;
    widget(int b,string ss):a(b),s(ss){}
};

void update(widget &data)
{
    data.a += 1;
    data.s += "233";
}

int main()
{
    widget data(2, "ljy");
    thread t(update, data);
    t.join();
    cout << data.a << " " << data.s << endl;//2 ljy

    system("pause");
    return 0;
}

mutex g_lock;

void func()
{
    //对互斥量加锁，如果互斥量不可用，便处于阻塞状态
    g_lock.lock();
    cout << "entered thread" << this_thread::get_id() << endl;
    this_thread::sleep_for(chrono::seconds(rand() % 10));
    cout << "leaving thread" << this_thread::get_id() << endl;
    //对互斥量解锁
    g_lock.unlock();
}

int main()
{
    //与rand配合使用，实现真正的随机
    srand((unsigned int)time(0));
    
    thread t1(func);
    thread t2(func);
    thread t3(func);

    t1.join();
    t2.join();
    t3.join();


    system("pause");
    return 0;
}

//实现一个线程安全容器
template<class T>
class container
{
private:
    recursive_mutex _lock;
    vector<T> _elements;
public:
    void add(T element)
    {
        _lock.lock();
        _elements.push_back(element);
        _lock.unlock();
    }

    void addrange(int index, vector<T>vec)
    {
        for (int i = 0; i < index; ++i)
        {
            _lock.lock();
            add(vec[i]);
            _lock.unlock();
        }
    }
    void dump()
    {
        _lock.lock();
        for (auto e : _elements)
            cout << e << endl;
        _lock.unlock();
    }
};

void func(container<int>& cont)
{
    vector<int>vec = { 1,2,3,4,5,6,7 };
    cont.addrange(3, vec);
}

int main()
{
    container<int> cont;

    thread t1(func,ref(cont));
    thread t2(func,ref(cont));
    thread t3(func,ref(cont));

    t1.join();
    t2.join();
    t3.join();

    cont.dump();

    system("pause");
    return 0;
}

explicit lock_guard (mutex_type& m);//必须要传递一个mutex作为构造参数,在构造函数中对mutex上锁  
lock_guard (mutex_type& m, adopt_lock_t tag);//tag=adopt_lock表示mutex已经在之前被上锁，这里lock_guard将拥有mutex的所有权  
lock_guard (const lock_guard&) = delete;//不允许copy constructor  

1 unique_lock() noexcept;    //可以构造一个空的unique_lock对象，此时并不拥有任何mutex

2 explicit unique_lock (mutex_type& m);//拥有mutex，并调用mutex.lock()对其上锁    

3 unique_lock (mutex_type& m, try_to_lock_t tag);//tag=try_lock表示调用mutex.try_lock()尝试加锁

4 unique_lock (mutex_type& m, defer_lock_t tag) noexcept;//tag=defer_lock表示不对mutex加锁，只管理mutex，此时mutex应该是没有加锁的

5 unique_lock (mutex_type& m, adopt_lock_t tag);//tag=adopt_lock表示mutex在此之前已经被上锁，此时unique_locl管理mutex

6 template <class Rep, class Period>
   unique_lock (mutex_type& m, const chrono::duration<Rep,Period>& rel_time);//在一段时间rel_time内尝试对mutex加锁,mutex.try_lock_for(rel_time)

7 template <class Clock, class Duration>
   unique_lock (mutex_type& m, const chrono::time_point<Clock,Duration>& abs_time);//mutex.try_lock_until(abs_time)直到abs_time尝试加锁

8 unique_lock (const unique_lock&) = delete;//禁止拷贝构造

9 unique_lock (unique_lock&& x);//获得x管理的mutex，此后x不再和mutex相关，x此后相当于一个默认构造的unique_lock,移动构造函数，具备移动语义,movable but not copyable

~unique_lock();//若unique_lock对象拥有管理的mutex的所有权，mutex没有被销毁或者unlock,那么将执行mutex::unlock()解锁，并不销毁mutex对象。
mutex_type* mutex() const noexcept;//返回unique_lock管理的mutex指针，但是unique_lock不会放弃对mutex的管理，若unique_lock对mutex上锁了，其有义务对mutex解锁
bool owns_lock() const noexcept;//当mutex被unique_lock上锁，且mutex没有解锁或析构，返回真，否则返回false
explicit bool operator () const noexcept;//同上

struct bank_account//银行账户  
{
    explicit bank_account(string name, int money)
    {
        sName = name;
        iMoney = money;
    }

    string sName;
    int iMoney;
    mutex mMutex;//账户都有一个锁mutex  
};
void transfer(bank_account &from, bank_account &to, int amount)//这里缺少一个from==to的条件判断个人觉得  
{
    unique_lock<mutex> lock1(from.mMutex, defer_lock);//defer_lock表示延迟加锁，此处只管理mutex  
    unique_lock<mutex> lock2(to.mMutex, defer_lock);
    lock(lock1, lock2);//lock一次性锁住多个mutex防止deadlock,这个是关键  
    from.iMoney -= amount;
    to.iMoney += amount;
    cout << "Transfer " << amount << " from " << from.sName << " to " << to.sName << endl;
}

void main()
{
    bank_account Account1("User1", 100);
    bank_account Account2("User2", 50);
    thread t1([&]() { transfer(Account1, Account2, 10); });//lambda表达式，注意此处Account1,Account2都是传入引用,值会发生改变  
    thread t2([&]() { transfer(Account2, Account1, 5); });
    t1.join();
    t2.join();

    system("pause");
}

lock( from.mMutex, to.mMutex );  
lock_guard<mutex> lock1( from.mMutex, adopt_lock );//adopt_lock表示mutex已经上锁，lock1将拥有from.mMutex  
lock_guard<mutex> lock2( to.mMutex, adopt_lock );  

mutex m;
condition_variable cond;
int flag = 0;
void producer() {
    this_thread::sleep_for(chrono::seconds(1));
    lock_guard<mutex> guard(m);
    flag = 100;
    cond.notify_one();
    cout << "notify..." << endl;
}
void customer() {
    unique_lock<mutex> lk(m);
    if (m.try_lock())
        cout << "mutex unlocked after unique_lock" << endl;
    else
        cout << "mutex locked after unique_lock" << endl;//输出  
    while (flag == 0) {
        cout << "wait..." << endl;
        cond.wait(lk);
    }
    if (m.try_lock())
        cout << "mutex unlocked after wait" << endl;
    else
        cout << "mutex locked after wait" << endl;//输出  
    cout << "flag==100? " << flag << endl;
}
/*
mutex locked after unique_lock
wait...
notify...
mutex locked after wait
flag==100? 100
*/
int main() {
    thread one(producer);
    thread two(customer);
    one.join();
    two.join();

    system("pause");
    return 0;
}

template<typename T>
class BlockingQueue
{
public:
    BlockingQueue(){}
    //lock_guard保证对队列的互斥访问,condition_variable唤醒阻塞线程，实现线程同步，Put操作应该也要有一个condition_variable
//我的理解:put也用unique_lock,在while中判断队列是否满了，若满了，调用condition_variable.wait阻塞自己
    void Put(const T& task)
    {
        //临界区
        {
            std::lock_guard<std::mutex> lock(_mutex);
            _queue.push_back(task);
        }
        _condvar.notify_all();
    }
    T Take()
    {
        std::unique_lock<std::mutex> lock(_mutex);
　　　　　//此处应该在while循环中调用，防止虚假唤醒
        _condvar.wait(lock, [this] {return !_queue.empty(); });
        assert(!_queue.empty());
        T front(_queue.front());
        _queue.pop_front();

        return front;
    }

    size_t Size() const
    {
        std::lock_guard<std::mutex> lock(_mutex);
        return _queue.size();
    }
private:
    BlockingQueue(const BlockingQueue& rhs);
    BlockingQueue& operator = (const BlockingQueue& rhs);
private:
    mutable std::mutex _mutex;
    std::condition_variable _condvar;
    std::list<T> _queue;//双向链表
};

int main()
{
    BlockingQueue<int> q;
    auto t1 = std::async(std::launch::async, [&q]() 
    {
        for (int i = 0; i < 10; ++i) 
        {
            q.Put(i);
        }
    });

    auto t2 = std::async(std::launch::async, [&q]() 
    {
        while (q.Size()) 
        {
            std::cout <<"t2 "<< q.Take() << std::endl;
        }
    });

    auto t3 = std::async(std::launch::async, [&q]() 
    {
        while (q.Size()) 
        {
            std::cout <<"t3 "<< q.Take() << std::endl;
        }
    });

    t1.wait();
    t2.wait();
    t3.wait();

    system("pause");
    return 0;
}

    std::promise<int> pr;
    std::thread t([](std::promise<int>& p) { p.set_value_at_thread_exit(9); }, std::ref(pr));
    std::future<int> f = pr.get_future();
    auto r = f.get();
    cout << r << endl;
    t.join();

    std::packaged_task<int()> task([](){ return 7; });
    std::thread t1(std::ref(task)); 
    std::future<int> f1 = task.get_future(); 
    auto r1 = f1.get();

int main()
{
    std::future<int> f1 = std::async(std::launch::async, []() {
        return 8;
    });

    cout << f1.get() << endl; //output: 8

    std::future<void> f2 = std::async(std::launch::async, []() {
        cout << 8 << endl;
    });

    f2.wait(); //output: 8

    std::future<int> future = std::async(std::launch::async, []() {
        std::this_thread::sleep_for(std::chrono::seconds(3));
        return 8;
    });

    std::cout << "waiting...\n";
    std::future_status status;
    do {
        status = future.wait_for(std::chrono::seconds(1));
        if (status == std::future_status::deferred) {
            std::cout << "deferred\n";
        }
        else if (status == std::future_status::timeout) {
            std::cout << "timeout\n";
        }
        else if (status == std::future_status::ready) {
            std::cout << "ready!\n";
        }
    } while (status != std::future_status::ready);

    std::cout << "result is " << future.get() << ‘\n‘;

    system("pause");
    return 0;
}

int a = 1;
int b = 2;

auto func = [=, &b](int c)->int {return b += a + c; };
cout<<func(a);