使用多线程优先的作业调度程序

Question

我即将启动一个创建作业调度程序的 C# .NET 4.0 项目。

1. 该作业没有截止日期，并且可能会长时间运行，长达数天。
2. 该作业有 3 个优先级：空闲、正常、关键；从最低到最高。
3. 新的就业岗位不断被创造。
4. 即使旧作业已创建很长时间，具有较高优先级的新作业也应优先于较低优先级的作业。
5. 每个作业将由单个长时间运行的线程处理。
6. 工作是可重入的。作业的状态会持久保存到数据库中，因此可以随时暂停作业或终止作业线程。

我的计划是使用信号量，并将并发条目数设置为系统核心数。队列中的每个作业都会创建一个新线程，并且所有线程一开始都会被信号量阻塞。

我的问题是保证当信号量调用release()方法时高优先级线程将首先进入信号量。可行吗？

我的第二个问题是，当更高优先级的作业线程存在时，让信号量内部的线程退出，并使退出的作业线程返回到线程队列以等待信号量。可行吗？

对于这两个问题，信号量是正确的方法吗？如果不是，你有什么建议？

Answer 1

好吧，我更倾向于以下内容...

首先，启动您想要的所有线程：

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

您将需要一个接口来描述任务的优先级

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

然后创建一个队列管理对象。这显然会变得更加复杂，因为它可能需要与您的数据库同步等...

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);
        }
    }
}

最后创建您的工作线程，如下所示：

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

Answer 2

对于这两个问题，信号量是正确的方法吗？如果没有，你有什么建议？

这确实取决于。通常，每个线程最好有多个作业，因为许多（尤其是长时间运行的）工作项将花费时间等待 CPU 以外的其他事物。例如，如果您正在从事从 WCF 服务中提取数据的工作，或遇到其他相关问题，您可能会花费大量时间被阻塞和闲置。

在这种情况下，最好让您的作业根据需要进行安排。在这种情况下，使用 ThreadPool 可能会更好。

但是，如果作业都是高 CPU 资源，那么您的方法可能是可取的。优先级队列可用于跟踪调度优先级，并决定运行哪个作业。

话虽这么说，我可能不会为此使用信号量。虽然它可以工作，但单个计数器（通过 Interlocked.Increment/Decrement 管理）和 ManualResetEvent 也可以工作，并且重量要轻得多。

Answer 3

有一个很棒的框架从 Java 移植到了 C#，请查看

http://quartznet.sourceforge.net/