ThreadSafeQueue< T > Class Template Reference

#include <ThreadSafeQueue.hpp>

Collaboration diagram for ThreadSafeQueue< T >:

Classes
struct	node

Public Member Functions
	ThreadSafeQueue ()
	~ThreadSafeQueue ()
	ThreadSafeQueue (const ThreadSafeQueue &other)=delete
ThreadSafeQueue &	operator= (const ThreadSafeQueue &other)=delete
std::shared_ptr< T >	try_pop ()
void	push (T &&new_value)
std::size_t	size ()
bool	empty ()
std::shared_ptr< T >	front ()

Private Member Functions
node *	get_tail ()
std::unique_ptr< node >	pop_head ()

Private Attributes
std::mutex	head_mutex
std::unique_ptr< node >	head
std::mutex	tail_mutex
node *	tail

Constructor & Destructor Documentation

ThreadSafeQueue() [1/2]

template<typename T >

ThreadSafeQueue< T >::ThreadSafeQueue ( )

inline

                     :
        head(new node), tail(head.get())
    {}

~ThreadSafeQueue()

template<typename T >

ThreadSafeQueue< T >::~ThreadSafeQueue ( )

inline

    {
        std::size_t qsize = size();
 
        for (std::size_t i = 0; i < qsize; i++)
            try_pop();
    }

References ThreadSafeQueue< T >::size(), and ThreadSafeQueue< T >::try_pop().

Here is the call graph for this function:

ThreadSafeQueue() [2/2]

template<typename T >

ThreadSafeQueue< T >::ThreadSafeQueue ( const ThreadSafeQueue< T > &  other )

delete

Member Function Documentation

empty()

template<typename T >

bool ThreadSafeQueue< T >::empty ( )

inline

    {
        std::unique_lock<std::mutex> head_lock(head_mutex);
 
        if(head.get() == get_tail())
            return true;
 
        return false;
    }

References ThreadSafeQueue< T >::get_tail(), ThreadSafeQueue< T >::head, and ThreadSafeQueue< T >::head_mutex.

Referenced by Horizon::Networking::Socket< SocketType >::handle_queue(), and Horizon::Networking::Socket< SocketType >::update().

Here is the call graph for this function:

Here is the caller graph for this function:

front()

template<typename T >

std::shared_ptr< T > ThreadSafeQueue< T >::front ( )

inline

    {
        std::unique_lock<std::mutex> head_lock(head_mutex);
        std::shared_ptr<T> front = head != nullptr ? std::make_shared<T>(*head->data) : nullptr;
        return std::move(front);
    }

References ThreadSafeQueue< T >::front(), ThreadSafeQueue< T >::head, and ThreadSafeQueue< T >::head_mutex.

Referenced by ThreadSafeQueue< T >::front(), and Horizon::Networking::Socket< SocketType >::handle_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

get_tail()

template<typename T >

node * ThreadSafeQueue< T >::get_tail ( )

inlineprivate

    {
        std::unique_lock<std::mutex> tail_lock(tail_mutex);
        return tail;
    }

References ThreadSafeQueue< T >::tail, and ThreadSafeQueue< T >::tail_mutex.

Referenced by ThreadSafeQueue< T >::empty(), and ThreadSafeQueue< T >::pop_head().

Here is the caller graph for this function:

operator=()

template<typename T >

ThreadSafeQueue & ThreadSafeQueue< T >::operator= ( const ThreadSafeQueue< T > &  other )

delete

pop_head()

template<typename T >

std::unique_ptr< node > ThreadSafeQueue< T >::pop_head ( )

inlineprivate

    {
        std::unique_lock<std::mutex> head_lock(head_mutex);
 
        if(head.get() == get_tail())
            return nullptr;
 
        std::unique_ptr<node> old_head = std::move(head);
        head = std::move(old_head->next);
        return old_head;
    }

References ThreadSafeQueue< T >::get_tail(), ThreadSafeQueue< T >::head, and ThreadSafeQueue< T >::head_mutex.

Referenced by ThreadSafeQueue< T >::try_pop().

Here is the call graph for this function:

Here is the caller graph for this function:

push()

template<typename T >

void ThreadSafeQueue< T >::push ( T &&  new_value )

inline

    {
        std::shared_ptr<T> new_data(
            std::make_shared<T>(std::move(new_value)));
        std::unique_ptr<node> p(new node);
        node *new_tail = p.get();
        std::unique_lock<std::mutex> tail_lock(tail_mutex);
        tail->data = new_data;
        tail->next = std::move(p);
        tail = new_tail;
    }

References ThreadSafeQueue< T >::node::data, ThreadSafeQueue< T >::node::next, ThreadSafeQueue< T >::tail, and ThreadSafeQueue< T >::tail_mutex.

Referenced by BOOST_AUTO_TEST_CASE(), Horizon::Networking::Socket< SocketType >::queue_buffer(), Horizon::Networking::AcceptSocketMgr< SocketType, NetworkThreadType >::set_socket_for_management(), Horizon::Networking::AcceptSocketMgr< SocketType, NetworkThreadType >::set_socket_for_removal(), and WorkerThreadPool::submit().

Here is the caller graph for this function:

size()

template<typename T >

std::size_t ThreadSafeQueue< T >::size ( )

inline

    {
        int count = 0;
        std::unique_lock<std::mutex> head_lock(head_mutex);
        std::unique_lock<std::mutex> tail_lock(tail_mutex);
        node const *n = head.get();
 
        while ((n = n->next.get())) {
            count++;
        }
 
        return count;
    }

References GridTypeListIterator::count(), ThreadSafeQueue< T >::head, ThreadSafeQueue< T >::head_mutex, ThreadSafeQueue< T >::node::next, and ThreadSafeQueue< T >::tail_mutex.

Referenced by BOOST_AUTO_TEST_CASE(), and ThreadSafeQueue< T >::~ThreadSafeQueue().

Here is the call graph for this function:

Here is the caller graph for this function:

try_pop()

template<typename T >

std::shared_ptr< T > ThreadSafeQueue< T >::try_pop ( )

inline

    {
        std::unique_ptr<node> old_head = pop_head();
        return old_head ? old_head->data : std::shared_ptr<T>();
    }

References ThreadSafeQueue< T >::pop_head().

Referenced by BOOST_AUTO_TEST_CASE(), Horizon::Networking::Socket< SocketType >::handle_queue(), Horizon::Networking::AcceptSocketMgr< SocketType, NetworkThreadType >::manage_sockets(), WorkerThreadPool::worker_thread(), and ThreadSafeQueue< T >::~ThreadSafeQueue().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

head

template<typename T >

std::unique_ptr<node> ThreadSafeQueue< T >::head

private

Referenced by ThreadSafeQueue< T >::empty(), ThreadSafeQueue< T >::front(), ThreadSafeQueue< T >::pop_head(), and ThreadSafeQueue< T >::size().

head_mutex

template<typename T >

std::mutex ThreadSafeQueue< T >::head_mutex

private

Referenced by ThreadSafeQueue< T >::empty(), ThreadSafeQueue< T >::front(), ThreadSafeQueue< T >::pop_head(), and ThreadSafeQueue< T >::size().

tail

template<typename T >

node* ThreadSafeQueue< T >::tail

private

Referenced by ThreadSafeQueue< T >::get_tail(), and ThreadSafeQueue< T >::push().

tail_mutex

template<typename T >

std::mutex ThreadSafeQueue< T >::tail_mutex

private

Referenced by ThreadSafeQueue< T >::get_tail(), ThreadSafeQueue< T >::push(), and ThreadSafeQueue< T >::size().

---

The documentation for this class was generated from the following file:

• src/Core/Multithreading/ThreadSafeQueue.hpp