// create a new pool with two threads
 auto pool = new ThreadPool!(int)(2);
 void delegate(int) f = (int x) { Stdout(x).newline; };

 // Now we have three ways of telling the pool to execute our jobs
 // First we can say we just want it done at some later point
 pool.append(f, 1);
 // Secondly we can ask for a job to be done as soon as possible, blocking
 // until it is started by some thread
 pool.assign(f, 2);
 // Finally we can say we either want it done immediately or not at all
 if (pool.tryAssign(f, 3))
     Stdout("Someone took the job!").newline;
 else
     Stdout("No one was available to do the job right now").newline;
 // After giving the pool some jobs to do, we need to give it a chance to
 // finish, so we can do one of two things.
 // Choice no. 1 is to finish what has already been assigned to the threads,
 // but ignore any remaining queued jobs
 //   pool.shutdown();
 // The other choice is to finish all jobs currently executing or in queue:
 pool.finish();

alias JobD ;

An alias for the type of delegates this thread pool considers a job

this(size_t workers, size_t q_size = 0);

Create a new ThreadPool.

Params:

workers	The amount of threads to spawn
q_size	The expected size of the queue (how many elements are preallocated)

void assign (JobD job, Args args);

Assign the given job to a thread immediately or block until one is available

bool tryAssign (JobD job, Args args);

Assign the given job to a thread immediately or return false if none is available. (Returns true if one was available)

void append (JobD job, Args args);

Put a job into the pool for eventual execution.

Warning:
Acts as a stack, not a queue as you would expect

size_t pendingJobs ();

Get the number of jobs waiting to be executed

size_t activeJobs ();

Get the number of jobs being executed

void shutdown ();

Finish currently executing jobs and drop all pending.

void finish ();

Complete all pending jobs and shutdown.