使用队列和多线程导出文档类型

private static void ExportDocTypes(IEnumerable<string> docTypes)
{
    var queue = new Queue<string>(docTypes);
    var tasks = new List<Task>();
    for (byte i = 0; i < threadCount; i++)  //threadCount is a const set to 4.
    {
        Action a = () =>
        {
            while(queue.Count() > 0) {
                var type = queue.Dequeue();
                ExportDocuments(type, i);  //i is only sent for response.write
            }
        };
        var t = new Task(a);
        t.Start();
        tasks.Add(t);
        System.Threading.Thread.Sleep(10);
    }
    while (tasks.Count() > 0)
    {
        foreach (var t in tasks)
        {
            if (t.IsCompleted)
            {
                t.Dispose();
                tasks.Remove(t);
            }
        }
        System.Threading.Thread.Sleep(1000);
    }
}

#1 楼

而不是查看您的特定代码-乍一看似乎非常非常有问题-让我直接回答您的问题：


C＃中多线程的最佳实践是什么？ />


不要。多线程是一个坏主意。程序很难通过单点控制流程来理解。为什么要在地球上增加第二，第三，第四...？您是否喜欢追踪难以置信的难以复制，无法理解的错误？您对弱记忆模型和强记忆模型之间的区别是否有百科全书知识？没有？然后不要编写多线程程序！流程是一个非常好的工作单元；如果有工作要做，请生成一个进程。
哦，所以无论如何都要进行多线程编程。在这种情况下，请使用可用的最高级别的抽象。直接针对线程编程意味着您可以编写有关作业的程序时编写有关工人的程序。记住，工人只是达到目的的手段；您真正想要完成的是工作。使用任务并行库：任务是工作，线程是工作程序。让TPL为您找出如何有效利用工人的方法。
等一下，让我们再回到第一点。问问自己，您是否真的需要并发？有了真正的并发性，我们实际上就可以同时在一个程序中拥有两个或多个控制点。通过模拟并发，控制的两个点可以使用处理器轮流使用，因此它们实际上不是并发的。在大多数情况下，我们最终得到的是模拟并发，因为线程多于处理器。这自然使我们得出这样的结论：也许实际的并发并不是我们所需要的。人们在很多时候真正想要的是异步。并发是实现异步的一种方法，但不是唯一的方法。使用C＃5中新的异步/等待功能来表示异步工作流。
如果您对上一点感到困惑，并且想稍等片刻，那么在一个进程中没有多个控制线程的情况下就无法实现异步，请阅读Stephen Cleary的文章“没有线程”。在理解多线程程序之前，请不要尝试编写它。
不惜一切代价避免共享内存。大多数线程错误是由于无法理解现实世界的共享内存语义所致。如果必须创建线程，则将它们视为进程：将它们提供给它们完成工作所需的一切，并让它们工作而无需修改与任何其他线程关联的内存。就像一个进程无法修改任何其他进程的内存一样。
哦，所以您想要跨线程共享内存，尽管这样做很容易出错。再次，让我回到使用可用的最高级别的工具。这些工具是由专家编写的。你不是专家。您是否知道如何将延迟计算的值写入字段，以便绝对保证延迟计算不会重复执行一次，并且无论任何给定处理器中的状态如何，都永远不会观察到该字段处于不一致状态缓存？我不。你可能不会。 Joe Duffy这样做了，这就是为什么您应该使用他编写的Lazy<T>原语而不是尝试自己编写。为什么要编写自己的共享内存的代码？然后为天国着想。我看到如此多的错误代码使人们进入头脑，而锁却是昂贵的，而且他们编写了这种令人费解的，令人费解的错误代码，从而逃避了一把锁的花费，而这花了他们十二纳米的时间。避免使用锁来节省成本，就像在抱怨拨动开关时花费太长时间才能到达灯泡一样。锁是确保内存一致性的强大工具。如果您打算在线程级别对共享内存进行编程，则避免了锁定的危险。
如果在任何生产代码中将Thread.Sleep与非零或一的参数一起使用，则可能做错了什么。线程很昂贵；您不付钱给工人睡觉，所以也不要付钱去睡觉。如果您通过睡眠来避免时间问题来解决正确性问题（就像您在代码中那样），那么您肯定做错了很多事情。多线程代码需要正确无视计时的偶然性。

#2 楼

您可以使用Parallel类：

private static void ExportDocTypes(IEnumerable<string> docTypes)
{
    int i = -1;
    Parallel.ForEach(docTypes, docType => ExportDocuments(docType, Interlocked.Increment(ref i)));
}

http://msdn.microsoft.com/zh-cn/library/system.threading.tasks.parallel_methods%28v=vs .110％29.aspx

#3 楼

我会这样做：

private static void ExportDocTypes(IEnumerable<string> docTypes)
{
    var queue = new ConcurrentQueue<string>(docTypes);
    var tasks = new List<Task>();

    for (byte i = 0; i < threadCount; i++)  //threadCount is a const set to 4.
    {
        byte iteration = i;
        Task t = Task.Factory.StartNew(() =>
        {
            string type;
            bool queueNotEmpty = queue.TryDequeue(out type);
            while(queueNotEmpty) 
            {
                ExportDocuments(type, iteration);  //i is only sent for response.write
                bool queueEmpty = queue.TryDequeue(out type);
            }
        });
        tasks.Add(t);
    }

    Task.WaitAll(tasks.ToArray());
    tasks.ForEach(task => task.Dispose());
}

使用ConcurrentQueue之类的东西，因为许多线程将同时访问它。另外，在Task上更多地使用Linq和静态方法来检查是否完成，而不是使用Thread.Sleep。 for循环，否则i将指向当前值，而不是该迭代时捕获的值。循环生成Task时需要注意的事项。