.net 4.0 .NET4.0线程.Tasks

我最近开始开发一个新的应用程序，它将利用任务并行性。我刚刚开始编写一个任务框架，但最近看到了许多关于新System.Threading.Tasks命名空间的文章，这些文章可能对我很有用（我宁愿使用现有的框架，也不愿使用自己的框架）

但是，查看MSDN，我还没有看到如何/如果我可以实现我正在寻找的功能：

• 依赖于完成的其他任务
• 能够等待执行相同操作的未知数量的任务（可能包装在相同的

  task

  对象中，该对象被多次调用）
• 设置任务的最大并发实例，因为它们使用共享资源，所以一次运行多个实例是没有意义的
• 提示优先级，或者调度器将具有较低最大并发实例的任务置于较高优先级（以便尽可能多地使用所述资源）
• 修改执行相同操作的任务优先级的能力（非常糟糕的示例，但是PredictWeather（明天）的优先级将高于PredictWeather（NextWeek））

有人能给我举个例子/告诉我如何做到这一点吗？干杯

C#用例：（请键入SO，以提供任何语法错误/打字错误）

**注意

Do（）

/

DoAfter（）

不应阻止调用线程*

class Application ()
{

    Task LeafTask = new Task (LeafWork) {PriorityHint = High, MaxConcurrent = 1};
    var Tree = new TaskTree (LeafTask); 

    Task TraverseTask = new Task (Tree.Traverse); 
    Task WorkTask = new Task (MoreWork); 
    Task RunTask = new Task (Run);

    Object SharedLeafWorkObject = new Object ();

    void Entry ()
    {
        RunTask.Do ();
        RunTask.Join (); // Use this thread for task processing until all invocations of RunTask are complete
    }

    void Run(){                           
        TraverseTask.Do ();

        // Wait for TraverseTask to make sure all leaf tasks are invoked before waiting on them 
        WorkTask.DoAfter (new [] {TraverseTask, LeafTask});

        if (running){
            RunTask.DoAfter (WorkTask);   // Keep at least one RunTask alive to prevent Join from 'unblocking'
        }
        else    
        {
            TraverseTask.Join();
            WorkTask.Join ();
        }
    } 

    void LeafWork (Object leaf){
        lock (SharedLeafWorkObject)  // Fake a shared resource
        {
            Thread.Sleep (200); // 'work'
        } 
    }

    void MoreWork ()
    {
        Thread.Sleep (2000); // this one takes a while
    }
}


class TaskTreeNode<TItem>
{
    Task LeafTask; // = Application::LeafTask
    TItem Item;

    void Traverse ()
    {
        if (isLeaf)
        { 
            // LeafTask set in C-Tor or elsewhere
            LeafTask.Do(this.Item);

            //Edit
            //LeafTask.Do(this.Item, this.Depth); // Deeper items get higher priority
            return;
        }
        foreach (var child in this.children)
        {
            child.Traverse (); 
        }
    }
}

类应用程序（）
{
任务LeafTask=新任务（LeafWork）{PriorityHint=High，MaxConcurrent=1}；
var Tree=新任务树（LeafTask）；
Task TraverseTask=新任务（Tree.Traverse）；
任务=新任务（更多工作）；
任务RunTask=新任务（运行）；
Object SharedLeafWorkObject=新对象（）；
无效分录（）
{
RunTask.Do（）；
RunTask.Join（）；//使用此线程进行任务处理，直到完成对RunTask的所有调用
}
无效运行（）{
TraverseTask.Do（）；
//等待TraverseTask以确保在等待它们之前调用了所有叶任务
WorkTask.DoAfter（新[]{TraverseTask，LeafTask}）；
如果（正在运行）{
RunTask.DoAfter（WorkTask）；//保持至少一个RunTask处于活动状态，以防止加入“取消阻止”
}
其他的
{
TraverseTask.Join（）；
Join（）；
}
} 
无效叶工作（对象叶）{
锁定（SharedLeafWorkObject）//伪造共享资源
{
线程。睡眠（200）；/“工作”
} 
}
无效工作（）
{
Thread.Sleep（2000）；//这个需要一些时间
}
}
类TaskTreeNode
{
任务LeafTask；/=应用程序：：LeafTask
滴度项目；
无效遍历（）
{
如果（isLeaf）
{ 
//在C-Tor或其他地方设置的LeaftTask
LeafTask.Do（此项）；
//编辑
//LeafTask.Do（this.Item，this.Depth）；//越深的项目优先级越高
返回；
}
foreach（此.children中的var child）
{
Traverse（）；
}
}
}

这里有很多例子：

有一份很棒的白皮书，涵盖了您在这里提到的许多细节：

“并行编程模式：理解和应用.NET Framework 4的并行模式”

在我的脑海里，我想你可以做你问题中列出的所有事情

• 依赖项等：Task.WaitAll（Task[]tasks）
• 调度程序：该库支持许多选项来限制正在使用的线程数，并支持提供您自己的调度程序。如果可能的话，我会避免改变线程的优先级。这可能会对调度程序产生负面影响，除非您提供自己的