第十五课：C++多线程细粒度锁队列

#include<thread>
#include<iostream>

using namespace std;
using namespace this_thread;

template<class T>

class threadsafe_queue
{
private:
    struct node
    {
        shared_ptr<T> date;  //智能指针
        unique_ptr<node> next;
    };

    //FIFO

    mutex head_mutex;
    unique_ptr<node> head;  //整个队列的容量（链表）
    mutex tail_mutex;
    node* tail;
    node* get_tail()
    {
        lock_guard<mutex>tail_lock(tail_mutex);
        return tail;
    }

    unique_ptr<node> pop_head()
    {
        lock_guard<mutex> head_lock(head_mutex);

        if (head.get() == get_tail())
        {
            return nullptr;
        }
        unique_ptr<node> old_head = move(head);
        head = move(old_head->next);
        return old_head;
    }

public:
    threadsafe_queue() :head(new node), tail(head.get()) {}
    threadsafe_queue(const threadsafe_queue& other) = delete;
    threadsafe_queue& operator = (const threadsafe_queue& other) = delete;

    //入队
    void push(T new_value)
    {
        shared_ptr<T> new_date(make_shared<T> (move(new_value)));
        unique_ptr<node> p(new node);

        node* const new_tail = p.get();
        lock_guard<mutex> tail_lock(tail_mutex);
        tail->date = new_date;
        tail->next = move(p);
        tail = new_tail;
    }

    //出队
    shared_ptr<T>try_pop()
    {
        unique_ptr<node> old_head = pop_head();
        return old_head ? old_head->date : shared_ptr<T>();
    }
};

void insertDate(threadsafe_queue<int>& test, int date)
{
    test.push(date);
}

void deleteDate(threadsafe_queue<int>& test)
{
    shared_ptr<int> result = test.try_pop();

    if (result == nullptr)
    {
        printf("没有数据\n");
    }
    else
    {
        printf("%d\n", *result);
    }
}


int main()
{

    vector<thread> t;

    threadsafe_queue<int> test;

    for (int i = 0; i < 5; i++)
    {
        t.push_back(thread(insertDate, ref(test), i));
        t.push_back(thread(deleteDate, ref(test)));
    }

    for (auto& v : t)
    {
        v.join();
    }
    return 0;
}/*
C++多线程细粒度锁队列

*/

template<class T>

class threadsafe_queue
{
private:
    struct node
    {
        shared_ptr<T> date;  //智能指针
        unique_ptr<node> next;
    };

    //FIFO

    mutex head_mutex;
    unique_ptr<node> head;  //整个队列的容量（链表）
    mutex tail_mutex;
    node* tail;
    node* get_tail()
    {
        lock_guard<mutex>tail_lock(tail_mutex);
        return tail;
    }

    unique_ptr<node> pop_head()
    {
        lock_guard<mutex> head_lock(head_mutex);

        if (head.get() == get_tail())
        {
            return nullptr;
        }
        unique_ptr<node> old_head = move(head);
        head = move(old_head->next);
        return old_head;
    }

public:
    threadsafe_queue() :head(new node), tail(head.get()) {}
    threadsafe_queue(const threadsafe_queue& other) = delete;
    threadsafe_queue& operator = (const threadsafe_queue& other) = delete;

    //入队
    void push(T new_value)
    {
        shared_ptr<T> new_date(make_shared<T> (move(new_value)));
        unique_ptr<node> p(new node);

        node* const new_tail = p.get();
        lock_guard<mutex> tail_lock(tail_mutex);
        tail->date = new_date;
        tail->next = move(p);
        tail = new_tail;
    }

    //出队
    shared_ptr<T>try_pop()
    {
        unique_ptr<node> old_head = pop_head();
        return old_head ? old_head->date : shared_ptr<T>();
    }
};

void insertDate(threadsafe_queue<int>& test, int date)
{
    test.push(date);
}

void deleteDate(threadsafe_queue<int>& test)
{
    shared_ptr<int> result = test.try_pop();

    if (result == nullptr)
    {
        printf("没有数据\n");
    }
    else
    {
        printf("%d\n", *result);
    }
    


}


int main()
{

    vector<thread> t;

    threadsafe_queue<int> test;

    for (int i = 0; i < 5; i++)
    {
        t.push_back(thread(insertDate, ref(test), i));
        t.push_back(thread(deleteDate, ref(test)));
    }

    for (auto& v : t)
    {
        v.join();
    }
    return 0;
}