explicit BlockingQueue(int cap):capacity_(cap){}

void push(T item){

std::unique_lock<std::mutex> lock(mtx_);

not_full_.wait(lock, [&](){return q_.size() < capacity_;});

q_.push(std::move(item));

not_empty_.notify_one();

}

T pop(){

std::unique_lock<std::mutex> lock(mtx_);

not_empty_.wait(lock, [&](){return !q_.empty();});

T item = std::move(q_.front());

q_.pop();

not_full_.notify_one();

return item;

}

size_t size(){

std::unique_lock<std::mutex> lock(mtx_);

return q_.size();

}

std::mutex mtx_;

size_t capacity_;

std::condition_variable not_full_; // 这里用了两个条件变量，语义更清晰，当然用一个也可以。

std::condition_variable not_empty_;

std::queue<T> q_; // 底层队列容器

BlockingQueue<int> bq(2);

std::thread t1([&](){

bq.push(999);

std::this_thread::sleep_for(std::chrono::milliseconds(1000));// 1s

});

std::thread t2([&](){

bq.push(777);

std::this_thread::sleep_for(std::chrono::milliseconds(1000));// 1s

});

std::thread t3([&](){

bq.push(666);

std::this_thread::sleep_for(std::chrono::milliseconds(1000));// 1s

});

std::this_thread::sleep_for(std::chrono::milliseconds(5000));// 1s

auto a = bq.pop();

std::cout << a << bq.size() << std::endl;

a = bq.pop();

std::cout << a << bq.size() << std::endl;

a = bq.pop();

std::cout << a << bq.size() << std::endl;

t1.join();

t2.join();

t3.join();

return 0;

}