fine/coarse grain 多线程实践

#ifndef __COARSE__QUEUE__H__#define __COARSE__QUEUE__H__#ifdef _MSC_VER#if _MSC_VER > 1000#pragma once#endif#endif#include <queue>#include <mutex>#include <memory>#include <condition_variable>namespace stc{template <typename type>class coarse_queue{typedef std::shared_ptr<type>shared_ptr;typedef std::queue<shared_ptr>queue;typedef coarse_queue<type>self;public:coarse_queue()                = default;coarse_queue(const self&)     = delete;self& operator =(const self&) = delete;void wait_and_pop(type&);bool try_pop(type&);shared_ptr wait_and_pop();shared_ptr try_pop();void push(type);bool empty()const;private:queue    m_queue;mutable std::mutex      m_mutex;std::condition_variable m_cv;};template <typename type>void coarse_queue<type>::wait_and_pop(type& value){std::unique_lock<std::mutex> lock(m_mutex);m_cv.wait(lock, [this] { return !m_queue.empty(); });value = std::move(*(m_queue.front()));m_queue.pop();}template <typename type>bool coarse_queue<type>::try_pop(type& value){std::lock_guard<std::mutex> lock(m_mutex);if (m_queue.empty()) return (false);//if the queue is empty then return false to the callervalue = std::move(*(m_queue.front()));m_queue.pop();return (true);}template <typename type>typename coarse_queue<type>::shared_ptrcoarse_queue<type>::wait_and_pop(){std::unique_lock<std::mutex> lock(m_mutex);m_cv.wait(lock, [this] {return !m_queue.empty(); });shared_ptr res = m_queue.front();m_queue.pop();return (res);}template <typename type>typename coarse_queue<type>::shared_ptrcoarse_queue<type>::try_pop(){std::lock_guard<std::mutex> lock(m_mutex);if (m_queue.empty()) return false;shared_ptr res = m_queue.front();m_queue.pop();return (res);}template <typename type>void coarse_queue<type>::push(type value){std::shared_ptr<type> item(std::make_shared<type>(value));std::lock_guard<std::mutex> lock(m_mutex);m_queue.push(item);m_cv.notify_one();}template <typename type>bool coarse_queue<type>::empty()const{std::lock_guard<std::mutex> lock(m_mutex);return (m_queue.empty());}}#endif

#ifndef __FINE__QUEUE__H__#define __FINE__QUEUE__H__#ifdef _MSC_VER#if _MSC_VER > 1000#pragma once#endif#endif#include <memory>#include <mutex>#include <condition_variable>namespace stc{template <typename type>struct list_node{std::unique_ptr<type> m_next;std::shared_ptr<type> m_data;list_node() :m_next(NULL){}}; template <typename type>class fine_queue{typedef fine_queue<type>  self;typedef std::shared_ptr<type> shared_ptr;typedef list_node<type>  list_node;public:fine_queue();fine_queue(const self&)  = delete;self& operator =(const self&) = delete;public:void push(type);bool empty()const;bool try_pop(type&);std::shared_ptr<type> try_pop();std::shared_ptr<type> wait_and_pop();void wait_and_pop(type&);private:list_node* get_tail();std::unique_ptr<list_node> pop_head();std::unique_lock<std::mutex> wait_for_data();std::unique_ptr<list_node> wait_pop_head();std::unique_ptr<list_node> wait_pop_head(type&);std::unique_ptr<list_node> try_pop_head();std::unique_ptr<list_node> try_pop_head(type&);private:list_node* m_tail;mutable std::mutex m_head_mutex;mutable std::mutex     m_tail_mutex;std::unique_ptr<list_node>   m_head;std::condition_variable m_cv;};template <typename type>fine_queue<type>::fine_queue():m_head(new list_node){m_tail = m_head.get();}template <typename type>void fine_queue<type>::push(type value){shared_ptr item(std::make_shared<type>(value));std::unique_ptr<list_node> node(new list_node);{std::lock_guard<std::mutex> lock(m_tail_mutex);m_tail->m_data= item;list_node* next = node.get();m_tail->m_next= std::move(node);m_tail= next;}m_cv.notify_one();}template <typename type>typename fine_queue<type>::list_node*fine_queue<type>::get_tail(){std::lock_guard<std::mutex> lock(m_tail);return (m_tail);}template <typename type>std::unique_ptr<list_node<type> > fine_queue<type>::pop_head(){std::unique_ptr<list_node> o_node = std::move(m_head);m_head = o_node->m_next;return (o_node);}template <typename type>std::unique_lock<std::mutex> fine_queue<type>::wait_for_data(){std::unique_lock<std::mutex> lock(m_head_mutex);m_cv.wait(lock, [this] { return this->m_head.get() != get_tail(); });return (std::move(lock));}template <typename type>std::unique_ptr<list_node<type> > fine_queue<type>::wait_pop_head(){std::unique_lock<std::mutex> lock(wait_for_data());return (pop_head());}template <typename type> std::unique_ptr<list_node<type> > fine_queue<type>::wait_pop_head(type& value){std::unique_lock<std::mutex> lock(wait_for_data);value = std::move(*m_head);return (pop_head());}template <typename type>std::shared_ptr<type> fine_queue<type>::wait_and_pop(){std::unique_ptr<list_node> res = this->wait_pop_head();return (res->m_data);}template <typename type>void fine_queue<type>::wait_and_pop(type& value){wait_pop_head(value);}template <typename type>std::unique_ptr<list_node<type> > fine_queue<type>::try_pop_head(){std::lock_guard<std::mutex> lock(m_head_mutex);if (m_head.get() == get_tail())return (std::unique_ptr<list_node>());return (pop_head());}template <typename type>std::unique_ptr<list_node<type> > fine_queue<type>::try_pop_head(type& value){std::lock_guard<std::mutex> lock(m_head_mutex);if (m_head.get() == get_tail())return (std::unique_ptr<list_node>());value = std::move(*m_head);return (pop_head());}template <typename type>std::shared_ptr<type> fine_queue<type>::try_pop(){std::unique_ptr<list_node> res = try_pop_head();return res ? (res->m_data) : (std::shared_ptr<type>());}template <typename type>bool fine_queue<type>::try_pop(type& value){const std::unique_ptr<list_node> res = try_pop_head(value);return (res);}template <typename type>bool fine_queue<type>::empty()const{std::lock_guard<std::mutex> lock(m_head_mutex);return (m_head.get() == get_tail());}}#endif