线程安全 阻塞队列

#include <iostream>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <wait.h>
#include <pthread.h>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
std::queue<int> que;
std::mutex mt;
const int maxn=5;
std::condition_variable p,c;
using namespace std;
int id=0;

template <typename  T>
class Tqueue {
public:
    int _capacity;
    Tqueue(int capacity):_capacity(capacity){}
    std::queue<T> que1;

    T push(T val){
        std::unique_lock<mutex> uni(mt);
        p.wait(uni, [&]() -> int { return que.size() < _capacity; });
        que.push(id);
        printf("push %d\n", id);
        if (que.size() == 1) {
            c.notify_one();
        }
        c.notify_one();
    }
    T  pop(){
        std::unique_lock<mutex> uni(mt);
        c.wait(uni, []() -> int { return !que.empty(); });
        int x = que.front();
        que.pop();
        printf("pop %d\n", x);
        p.notify_one();
        return x;
    }

    T front(){
        std::unique_lock<mutex> uni(mt);
        c.wait(uni, []() -> int { return !que.empty(); });
        T x = que.front();
        printf("front() %d\n", x);
        return  x;
    }
};
void produce(Tqueue<int> &tque){
    while(id<100) {
        tque.push(++id);
       // sleep(1);
    }
}
void consume(Tqueue<int> &tque){
   while(id<20) {
       tque.pop();
       //sleep(1);
   }
}

int main() {

    Tqueue<int> tque(5);
    std::cout << "starting first helper...\n";
    std::thread helper1(produce,std::ref(tque));

    std::cout << "starting second helper...\n";
    std::thread helper2(consume,std::ref(tque));

    std::cout << "waiting for helpers to finish..." << std::endl;
    helper1.join();
    helper2.join();

    std::cout << "done!\n";

return 0;

}