chapter 6 code

ch6/queuelist2.cpp

@@ -0,0 +1,154 @@
+#include <iostream>
+#include <queue>
+#include <memory>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+
+template <typename T>
+class queue
+{
+  private:
+    struct node
+    {
+        std::shared_ptr<T> data;
+        std::unique_ptr<node> next;
+    };
+
+    std::mutex head_mutex;
+    std::unique_ptr<node> head;
+    std::mutex tail_mutex;
+    node *tail;
+    std::condition_variable data_cond;
+
+    node *get_tail()
+    {
+        std::lock_guard<std::mutex> tail_lock(tail_mutex);
+        return tail;
+    }
+
+    std::unique_ptr<node> pop_head()
+    {
+        std::unique_ptr<node> old_head = std::move(head);
+        head = std::move(old_head->next);
+        return old_head;
+    }
+
+    std::unique_ptr<node> try_pop_head()
+    {
+        std::lock_guard<std::mutex> head_lock(head_mutex);
+        if (head.get() == get_tail()) {
+            return std::unique_ptr<node>();
+        }
+        return pop_head();
+    }
+
+    std::unique_ptr<node> try_pop_head(T& value)
+    {
+        std::lock_guard<std::mutex> head_lock(head_mutex);
+        if (head.get() == get_tail()) {
+            return std::unique_ptr<node>();
+        }
+        value = std::move(*head->data);
+        return pop_head();
+    }
+
+    std::unique_lock<std::mutex> wait_for_data()
+    {
+        std::unique_lock<std::mutex> head_lock(head_mutex);
+        data_cond.wait(head_lock, [&]{return head.get() != queue::get_tail();});
+        return std::move(head_lock);
+    }
+
+    std::unique_ptr<node> wait_pop_head()
+    {
+        std::unique_lock<std::mutex> head_lock(wait_for_data());
+        return pop_head();
+    }
+
+    std::unique_ptr<node> wait_pop_head(T& value)
+    {
+        std::unique_lock<std::mutex> head_lock(wait_for_data());
+        value = std::move(*head->data);
+        return pop_head();
+    }
+
+  public:
+    queue():head(new node),tail(head.get())
+    {}
+
+    queue(const queue& other) = delete;
+    queue& operator=(const queue& other) = delete;
+
+    std::shared_ptr<T> try_pop()
+    {
+        std::unique_ptr<node> old_head = try_pop_head();
+        return old_head ? old_head->data : std::shared_ptr<T>();
+    }
+
+    bool try_pop(T& value)
+    {
+        std::unique_ptr<node> const old_head = try_pop_head(value);
+        return old_head;
+    }
+
+    std::shared_ptr<T> wait_and_pop()
+    {
+        std::unique_ptr<node> const old_head = wait_pop_head();
+        return old_head->data;
+    }
+
+    void wait_and_pop(T& value) 
+    {
+        std::unique_ptr<node> const old_head = wait_pop_value(value);
+    }
+
+    void push(T new_value)
+    {
+        std::shared_ptr<T> new_data(
+            std::make_shared<T>(std::move(new_value)));
+        std::unique_ptr<node> p(new node);
+        {
+            std::lock_guard<std::mutex> tail_lock(tail_mutex);
+            tail->data = new_data;
+            node *const new_tail = p.get();
+            tail->next = std::move(p);
+            tail = new_tail;
+        }
+        data_cond.notify_one();
+    }
+
+    void empty()
+    {
+        std::lock_guard<std::mutex> head_lock(head_mutex);
+        return (head.get(0 == get_tail()));
+    }
+};
+
+
+void push(queue<int>* q)
+{
+    for (int i = 0; i < 10; ++i) {
+        printf("pushing %d\n", i);
+        q->push(i);
+    }
+}
+
+void pop(queue<int>* q)
+{
+    int i = 0;
+    for (int i = 0; i < 10; ++i) {
+        printf("poping %d\n", *q->wait_and_pop());
+    }
+}
+
+int main()
+{
+    queue<int> q;
+    std::thread th1(push,&q);
+    std::thread th2(pop,&q);
+    th1.join();
+    th2.join();
+    return 0;
+}
+