Question

I am about to start a C# .NET 4.0 project that creates a job scheduler.

1. The job has no due date, and are potentially long running, up to days.
2. The job has 3 priorities: idle, normal, critical; from lowest to highest.
3. New job(s) are continuously being created.
4. Newer job with higher priority should take precedence over lower priority job even if the old job has been created for a long time.
5. Each job will be handled by single long running thread.
6. Job are re-entrant. The state of job is persisted to the database, so it is okay to pause the job or terminate the job thread at anytime.

My plan is to use a semaphore, and set the number of concurrent entries to the number of system cores. A new thread will be created for every jobs in queue, and all thread will be blocked by the semaphore in the beginning.

My problem is to guarantee high priority thread will enter the semaphore first when semaphore calls release() method. Doable?

My second problem is to have a thread that is inside the semaphore to exit when higher priority job thread come to existence and have the exiting job thread go back to the thread queue to wait for the semaphore. Doable?

For those two problems, is semaphore the right approaches? If not what do you suggest?

Answer 1

Well, I would lean more towards something like the following…

First, Start all the threads you want:

for(int i=0; i < Environment.ProcessorCount; i++)
{
    Thread t = new Thread(RunWork);
    // setup thread
    t.Start();
    threads.Add(t);
}

You will need an interface to describe the priority of a task

interface ITask {
    PrioirtyType Prioirty { get; }
    bool Complete { get; }
    void PerformOneUnitOfWork();
}

Then create a Queue management object. This would obviously get more complicated as it may need to sync with your database, etc…

class MyQueue<TJob> where TJob : ITask 
{
    Queue<TJob> high, med, low;
    bool GetNextJob(ref TJob work)
    {
        if(work.Priority == PriorityType.High && !work.Complete)
            return true;
        lock(this)
        {
            if(high.Count > 0)
            {
                Enqueue(work);//requeue to pick back up later
                work = high.Dequeue();
                return true;
            }
            if(work.Priority == PriorityType.Med && !work.Complete)
                return true;
            if(med.Count > 0)
            {
                Enqueue(work);//requeue to pick back up later
                work = med.Dequeue();
                return true;
            }
            if(!work.Complete)
                return true;
            if(low.Count > 0)
            {
                work = low.Dequeue();
                return true;
            }
            work = null;
            return false;
        }

    void Enqueue(TJob work)
    {
        if(work.Complete) return;
        lock(this)
        {
            else if(work.Priority == PriorityType.High) high.Enqueue(work);
            else if(work.Priority == PriorityType.Med) med.Enqueue(work);
            else low.Enqueue(work);
        }
    }
}

And Lastly create your worker thread something like the following:

public void RunWork()
{
    ITask job;
    while(!_shutdown.WaitOne(0))
    {
        if(queue.GetNextJob(ref job))
            job.PerformOneUnitOfWork();
        else
            WaitHandle.WaitAny(new WaitHandle[] { _shutdown, queue.WorkReadyHandle });
    }
}