//
// Created by andrew on 2021年5月29日.
//
#include <iostream>
#include <mutex>
#include <thread>
#include <queue>
#include <condition_variable>
#include <ctime>
#include <unistd.h>
#include <map>
#include <deque>

using namespace std;


class ConditionVariable {
public:
 ~ConditionVariable() = default;

 ConditionVariable() = default;

 const queue<int> &getDataQueue() const {
 return data_queue;
 }

 void setDataQueue(const queue<int> &dataQueue) {
 data_queue = dataQueue;
 }

 void insertDataQueue(int insertData) {
 data_queue.push(insertData);
 }

 void dataPrepare(int data) {


 std::unique_lock<std::mutex> lk(m_mut);
 data_cont.wait(lk, [this]{return !data_queue.empty();});
 }

private:
 // 定义互斥锁
 mutable std::mutex m_mut;
 std::queue<int> data_queue;
 std::condition_variable data_cont;

};

// std::adopt_lock, std::defer_lock
std::mutex foo,bar;

void task_a () {
 std::lock (foo,bar); // simultaneous lock (prevents deadlock)
 // adopt_lock 获取一把已经加锁的锁
 std::cout << "lock foo bar " << std::endl;
 std::unique_lock<std::mutex> lck1 (foo,std::adopt_lock);
 std::unique_lock<std::mutex> lck2 (bar,std::adopt_lock);
 std::cout << "task a\n";
 // (unlocked automatically on destruction of lck1 and lck2)
}

/*
 * 桃之夭夭。灼灼其华,之子于归,宜其室家
 * */

void task_b () {
 // foo.lock(); bar.lock(); // replaced by:
 std::unique_lock<std::mutex> lck1, lck2;
 // defer_lock 构造 unique_lock 但是先不进行加锁
 sleep(1);

 lck1 = std::unique_lock<std::mutex>(bar,std::defer_lock);
 lck2 = std::unique_lock<std::mutex>(foo,std::defer_lock);
 std::cout << "after defer lock " << std::endl;
 sleep(10);
 std::lock (lck1,lck2); // simultaneous lock (prevents deadlock)
 std::cout << "task b\n";
 // (unlocked automatically on destruction of lck1 and lck2)
}




class MoveData{
public:
 int data{};
 std::string name{};
 std::string address{};
 void show() const {
 std::cout << data << name << address << std::endl;
 }
};

void move_test1(MoveData &data) {

 MoveData moveData;
 moveData.data = 9;
 moveData.name = "sting";
 moveData.address = "127.0.0.1";
 data = std::move(moveData);

 // 将内存降低到和当前的队列容量保持一致的水平
 /*std::deque<int> deque_data;
 deque_data.shrink_to_fit()*/

}

void move_test(MoveData &data) {
 move_test1(data);
}


int main(int argc, char *argv[]) {

 std::thread th1 (task_a);
 std::thread th2 (task_b);
 th1.join();
 th2.join();

 MoveData pData;
 move_test(pData);
 pData.show();



 return 0;
}