ThreadPool::Queue Class Reference

#include <threadpool.hh>

Collaboration diagram for ThreadPool::Queue:

Public Types
using	Ptr = std::shared_ptr< Queue >
using	WeakPtr = std::weak_ptr< Queue >

Public Member Functions
	~Queue ()
std::shared_ptr< Scroom::Detail::ThreadPool::QueueImpl >	get ()
std::shared_ptr< WeakQueue >	getWeak ()

Static Public Member Functions
static Ptr	create ()
	ThreadPool::Queue.
static Ptr	createAsync ()

Private Member Functions
	Queue ()
	Queue (const Queue &)=delete
	Queue (Queue &&)=delete
Queue &	operator= (const Queue &)=delete
Queue &	operator= (Queue &&)=delete

Private Attributes
std::shared_ptr< WeakQueue >	weak

Detailed Description

Represent a Queue in the ThreadPool.

If pass in a Queue object when you schedule() your job, then your job will be scheduled on that particular queue. This does not in any way affect the order in which jobs are executed. Use priority for that. Instead, if you later delete your Queue, any jobs scheduled on that Queue will not be executed any more.

When you delete the Queue, your thread will block until any jobs currently being executed have finished. I.e. after the Queue is destroyed, no jobs will be running any more, nor will any be run in the future. This can cause deadlocks if a job running on a ThreadPool tries to destroy its own queue.

To avoid deadlock, you should make sure that jobs running on the ThreadPool only have references to WeakQueue objects, or you should create your Queue using createAsync(). This will do the actual Queue destruction on a separate thread. As a result, after the last reference to the Queue object goes out of scope, jobs on the Queue may continue running for some time.

Note

If you delete the Queue, the associated jobs will not actually be deleted. Instead, when the time comes to execute the job, a check is done whether the Queue still exists. If it doesn't, the job is silently discarded.

Member Typedef Documentation

Ptr

using ThreadPool::Queue::Ptr = std::shared_ptr<Queue>

WeakPtr

using ThreadPool::Queue::WeakPtr = std::weak_ptr<Queue>

Constructor & Destructor Documentation

~Queue()

ThreadPool::Queue::~Queue

(

)

{ weak->get()->deletingQueue(); }

Queue() [1/3]

ThreadPool::Queue::Queue ( )

private

  : weak(WeakQueue::create())
{
}

Queue() [2/3]

ThreadPool::Queue::Queue ( const Queue &  )

privatedelete

Queue() [3/3]

ThreadPool::Queue::Queue ( Queue &&  )

privatedelete

Member Function Documentation

create()

ThreadPool::Queue::Ptr ThreadPool::Queue::create ( )

static

ThreadPool::Queue.

When the last reference goes out of scope, synchronously destroy the Queue, blocking until any currently running jobs are finished.

{ return ThreadPool::Queue::Ptr(new ThreadPool::Queue()); }

Referenced by ThreadPool::defaultQueue(), and CompressedTile::observerAdded().

Here is the caller graph for this function:

createAsync()

ThreadPool::Queue::Ptr ThreadPool::Queue::createAsync ( )

static

When the last reference goes out of scope, asynchronously destroy the Queue. Jobs scheduled on the Queue may continue running for some time.

{ return {new ThreadPool::Queue(), AsyncDeleter<ThreadPool::Queue>()}; }

Referenced by TileViewState::kick(), and Scroom::TiledBitmap::scheduleLoadingBitmap().

Here is the caller graph for this function:

get()

QueueImpl::Ptr ThreadPool::Queue::get

(

)

{ return weak->get(); }

getWeak()

ThreadPool::WeakQueue::Ptr ThreadPool::Queue::getWeak

(

)

{ return weak; }

operator=() [1/2]

Queue & ThreadPool::Queue::operator= ( const Queue &  )

privatedelete

operator=() [2/2]

Queue & ThreadPool::Queue::operator= ( Queue &&  )

privatedelete

Member Data Documentation

weak

std::shared_ptr<WeakQueue> ThreadPool::Queue::weak

private

---

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

• libs/threadpool/inc/scroom/threadpool.hh
• libs/threadpool/src/threadpoolimpl.cc