C# 多线程和加速

我有下面的代码。我希望在多个线程上开始文件创建。目标是，当我在多个线程上创建10个文件时，它将花费更少的时间。据我所知，我需要引入异步调用元素来实现这一点

我应该在这段代码中做什么更改

using System;
using System.Text;
using System.Threading;
using System.IO;
using System.Diagnostics;

namespace MultiDemo
{
    class MultiDemo
    {
        public static void Main()
        {
            var stopWatch = new Stopwatch();
            stopWatch.Start();
            // Create an instance of the test class.
            var ad = new MultiDemo();

            //Should create 10 files in a loop.
            for (var x = 0; x < 10; x++)
            {
                var y = x;
                int threadId;
                var myThread = new Thread(() => TestMethod("outpFile", y, out threadId));
                myThread.Start();
                myThread.Join();
                //TestMethod("outpFile", y, out threadId);
            }
            stopWatch.Stop();
            Console.WriteLine("Seconds Taken:\t{0}",stopWatch.Elapsed.TotalMilliseconds);
        }

        public static void TestMethod(string fileName, int hifi, out int threadId)
        {
            fileName = fileName + hifi;
            var fs = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite);
            var sw = new StreamWriter(fs, Encoding.UTF8);
            for (int x = 0; x < 10000; x++)
                {
                    sw.WriteLine(DateTime.Now.ToString());
                }
            sw.Close();
           threadId = Thread.CurrentThread.ManagedThreadId;
            Console.WriteLine("{0}",threadId);
        }
    }
}

使用系统；
使用系统文本；
使用系统线程；
使用System.IO；
使用系统诊断；
名称空间多重演示
{
类多重演示
{
公共静态void Main（）
{
var stopWatch=新秒表（）；
秒表。开始（）；
//创建测试类的实例。
var ad=new MultiDemo（）；
//应该在一个循环中创建10个文件。
对于（变量x=0；x<10；x++）
{
变量y=x；
int-threadId；
var myThread=new Thread（（）=>TestMethod（“outpFile”，y，out threadId））；
myThread.Start（）；
myThread.Join（）；
//TestMethod（“outpFile”，y，out-threadId）；
}
秒表；
WriteLine（“所用的秒数：\t{0}”，stopWatch.appeased.totalmillizes）；
}
公共静态void TestMethod（字符串文件名、int-hifi、out-int-threadId）
{
fileName=fileName+hifi；
var fs=new FileStream（文件名，FileMode.OpenOrCreate，FileAccess.ReadWrite）；
var sw=新的StreamWriter（fs，Encoding.UTF8）；
对于（int x=0；x<10000；x++）
{
sw.WriteLine（DateTime.Now.ToString（））；
}
sw.Close（）；
threadId=Thread.CurrentThread.ManagedThreadId；
WriteLine（“{0}”，threadId）；
}
}
}

---

现在，如果我对代码中的线程创建部分进行注释，并在一个循环中调用testMethod 10次，它比线程创建尝试处理的多个线程要快。

提高速度是错误的，多线程用于并行工作，而不是加速。

提高速度是错误的，多线程用于并行工作，但不用于加速

也许这并不能直接回答您的问题，但这是我的想法。代码中的瓶颈不太可能是处理器。我敢打赌，磁盘IO比CPU处理要花更多的时间。因此，我不相信创建新线程会有任何帮助（所有线程都将尝试写入同一磁盘）。我认为这是一个过早优化的例子。如果我是你，我只会在一个线程上完成这一切。

也许这并不能直接回答你的问题，但这是我对这件事的看法。代码中的瓶颈不太可能是处理器。我敢打赌，磁盘IO比CPU处理要花更多的时间。因此，我不相信创建新线程会有任何帮助（所有线程都将尝试写入同一磁盘）。我认为这是一个过早优化的例子。如果我是你，我会在一个线程上完成这一切。

那么你为什么决定使用多线程呢？启动一个新线程的代价可能高于一个简单的循环。这不是你可以盲目决定的事情。。。如果您坚持使用线程，还可以检查的托管/使用情况，这可以通过重新使用现有线程来降低创建新线程的成本。

那么您为什么决定使用多线程呢？启动一个新线程的代价可能高于一个简单的循环。这不是你可以盲目决定的事情。。。如果您坚持使用线程，还可以检查的托管/使用情况，这可以通过重新使用现有线程来降低创建新线程的成本。

您的代码的线程版本正在做额外的工作，因此速度较慢并不奇怪

当您执行以下操作时：

var myThread = new Thread(() => TestMethod("outpFile", y, out threadId));
myThread.Start();
myThread.Join();

for (int i = 0; i < 10; ++i)  
{ 
   new Action(() => { TestMethod("outpFile"); }).BeginInvoke(null,null); 
}
Console.ReadLine();

…您正在创建一个线程，让它调用

TestMethod

，然后等待它完成创建和启动线程的额外开销会比不使用任何线程调用

TestMethod

更慢。

如果启动所有线程，然后等待它们完成，则可能会看到更好的性能，例如：

var workers = new List<Thread>();
for (int i = 0; i < 10; ++i) 
{
   var y = x;
   int threadId;
   var myThread = new Thread(() => TestMethod("outpFile", y, out threadId));
   myThread.Start();
   workers.Add(myThread);
}
foreach (var worker in workers) worker.Join();

var workers=newlist（）；
对于（int i=0；i<10；++i）
{
变量y=x；
int-threadId；
var myThread=new Thread（（）=>TestMethod（“outpFile”，y，out threadId））；
myThread.Start（）；
workers.Add（myThread）；
}
foreach（var-worker-in-workers）worker.Join（）；

您的代码的线程版本正在做额外的工作，因此速度变慢并不奇怪

当您执行以下操作时：

var myThread = new Thread(() => TestMethod("outpFile", y, out threadId));
myThread.Start();
myThread.Join();

for (int i = 0; i < 10; ++i)  
{ 
   new Action(() => { TestMethod("outpFile"); }).BeginInvoke(null,null); 
}
Console.ReadLine();

…您正在创建一个线程，让它调用

TestMethod

，然后等待它完成创建和启动线程的额外开销会比不使用任何线程调用

TestMethod

更慢。

如果启动所有线程，然后等待它们完成，则可能会看到更好的性能，例如：

var workers = new List<Thread>();
for (int i = 0; i < 10; ++i) 
{
   var y = x;
   int threadId;
   var myThread = new Thread(() => TestMethod("outpFile", y, out threadId));
   myThread.Start();
   workers.Add(myThread);
}
foreach (var worker in workers) worker.Join();

var workers=newlist（）；
对于（int i=0；i<10；++i）
{
变量y=x；
int-threadId；
var myThread=new Thread（（）=>TestMethod（“outpFile”，y，out threadId））；
myThread.Start（）；
workers.Add（myThread）；
}
foreach（var-worker-in-workers）worker.Join（）；

您否定了多线程的好处，因为您加入了每个线程，并在创建和启动下一个线程之前等待它完成

相反，在创建和启动线程时将其添加到列表中，然后在线程列表中循环，按顺序连接它们，直到它们完成

using System.Collections.Generic;
List<Thread> threads= new List<Thread>();
//Should create 10 files in a loop.
for (var x = 0; x < 10; x++)
{
    var y = x;
    int threadId;
    var myThread = new Thread(() => TestMethod("outpFile", y, out threadId));
    threads.Add(myThread);
    myThread.Start();
    //myThread.Join();
    //TestMethod("outpFile", y, out threadId);
}
foreach (var thread in threads) thread.Join();

使用System.Collections.Generic；
列表线程=新列表（）；
//应该在一个循环中创建10个文件。
对于（变量x=0；x<10；x++）
{
变量y=x；
int-threadId；
var myThread=新线程（（）=>TestMethod(