多线程性能提升

时间：2011-09-15 20:13:29

标签： c# multithreading silverlight performance

有人可以告诉我为什么这些DoCalculation方法中的一个比另一个快得多（比如快40％）？

我有一个等待设置ManualResetEvents的主线程：

private void LayoutRoot_Loaded(object sender, RoutedEventArgs e)
{
ThreadPool.QueueUserWorkItem((obj) =>
{
    ManualResetEvent[] finishcalc = new ManualResetEvent[] 
    { 
        new ManualResetEvent(false), 
        new ManualResetEvent(false), 
        new ManualResetEvent(false), 
        new ManualResetEvent(false), 
        new ManualResetEvent(false), 
        new ManualResetEvent(false) 
    };
    TimeSpan time1 = new TimeSpan(DateTime.Now.Ticks);
    DoCalculation(rand.Next(10), rand.Next(10), 1, finishcalc[0]);
    DoCalculation(rand.Next(10), rand.Next(10), 2, finishcalc[1]);
    DoCalculation(rand.Next(10), rand.Next(10), 3, finishcalc[2]);
    DoCalculation(rand.Next(10), rand.Next(10), 4, finishcalc[3]);
    DoCalculation(rand.Next(10), rand.Next(10), 5, finishcalc[4]);
    DoCalculation(rand.Next(10), rand.Next(10), 6, finishcalc[5]);

    if (WaitHandle.WaitAll(finishcalc))
    {            
        TimeSpan time2 =new TimeSpan(DateTime.Now.Ticks);
        AddTextAsync(string.Format("DoCalculation Finish in {0}\n" ,(time2-time1).TotalSeconds));
    }
});
}

然后我有一个方法创建另一个线程来按顺序进行一些计算，这就是，我需要前一个线程的结果继续下面的一个。我找到了两种方法来实现它，这是针对Silverlight的。 / p>

在第一个例子中，我正在创建一个新线程，它等待每个连续计算完成后再继续：

void DoCalculation(int number1, int number2, int callid, ManualResetEvent calcdone)
{
    ThreadPool.QueueUserWorkItem((obj0) =>
    {
        AddTextAsync(string.Format("The values for Callid {0} are {1} and {2}\n", callid, number1, number2));
        int result = 0;
        ManualResetEvent mresetevent = new ManualResetEvent(false);
        ThreadPool.QueueUserWorkItem((obj) =>
        {
            result = number1 + number2;
            mresetevent.Set();
        });
        mresetevent.WaitOne();
        mresetevent.Reset();
        ThreadPool.QueueUserWorkItem((obj2) =>
        {
            result *= result;
            mresetevent.Set();
        });
        mresetevent.WaitOne();
        mresetevent.Reset();

        ThreadPool.QueueUserWorkItem((obj2) =>
        {
            result *= 2;
            mresetevent.Set();
        });
        mresetevent.WaitOne();
        AddTextAsync(string.Format("The result for Callid {0} is {1} \n", callid, result));
        calcdone.Set();
    });
}

DoCalculation的第二个例子我使用一个类作为链接将Action作为参数传递给ThreadPool并将其用作回调来在链中创建第二个和第三个线程：

链接类：

public class CalcParams
{
    public int CallID;
    public ManualResetEvent ManualReset;
    public int Result;
    public Action<int, ManualResetEvent, int> CallbackDone;
}

异步服务的示例:: 

public static void DownloadDataInBackground(CalcParams calcparams)
{
    WebClient client = new WebClient();
    Uri uri = new Uri("http://www.google.com");
    client.DownloadStringCompleted += (s, e) =>
    {
        CalcParams localparams = (CalcParams)e.UserState;
        localparams.CallbackDone(e.Result.Length + localparams.Result, localparams.ManualReset, localparams.CallID);
    };
    client.DownloadStringAsync(uri, calcparams);
}

改进的doCalculation方法：

void DoCalculation(int number1, int number2, int callid, ManualResetEvent calcdone)
{
    ThreadPool.QueueUserWorkItem((obj0) =>
    {
        int result = number1+number2;
        doCalculationService.DownloadDataInBackground(new CalcParams()
        {
            Result = result,
            ManualReset = calcdone,
            CallID = callid,
            CallbackDone = (r, m, i) =>
            {
                int sqrt = r * r;
                doCalculationService.DownloadDataInBackground(new CalcParams()
                {
                    Result = sqrt,
                    CallID = i,
                    ManualReset = m,
                    CallbackDone = (r2, m2, i2) =>
                    {
                        int result2 = r2 * 2;
                        AddTextAsync(string.Format("The result for Callid {0} is {1} \n", i2, result2));
                        m2.Set();
                    }
                });
            }
        });
    });
}

谢谢。

2 个答案:

答案 0 :(得分：3)

没有充分的理由致电ThreadPool.QueueUserWorkItem，然后立即等待它完成。也就是说，写下这个：

ThreadPool.QueueUserWorkItem(() =>
    {
        // do stuff
        mevent.Set();
    });
mevent.WaitOne();

不会给你带来任何好处。你的主线程最终等待。事实上，这比写作更糟糕：

// do stuff

因为线程池必须启动一个线程。

您可以通过删除所有嵌套的“异步”工作来简化和加速您的第一个DoCalculation方法：

void DoCalculation(int number1, int number2, int callid, ManualResetEvent calcdone)
{
    ThreadPool.QueueUserWorkItem((obj0) =>
    {
        AddTextAsync(string.Format("The values for Callid {0} are {1} and {2}\n", callid, number1, number2));
        int result = 0;

        result = number1 + number2;
        result *= result;
        result *= 2;

        AddTextAsync(string.Format("The result for Callid {0} is {1} \n", callid, result));
        calcdone.Set();
    });
}

编辑以回应更新的问题

你的新例子＃3在某种程度上简化了事情，但仍然忽略了这一点。以下是您的新DoCalculation方法执行时会发生的情况：

  1. ThreadQueue.QueueUserWorkItem创建一个新线程，并退出DoCalculation方法。您现在有一个后台线程正在运行。我们称之为Thread 1。
  2. 代码调用DownloadDataInBackground。该方法启动另一个线程以异步方式下载数据。称之为线程2。
  3. 线程1退出。
  4. 当线程2完成下载时，它会调用完成回调，再次调用DownloadDataInBackground。这将创建线程3，开始执行，线程2退出。
  5. 当线程3完成下载时，它会调用完成回调，进行计算，输出一些数据并退出。

    6. 所以你启动了三个主题。在任何时候都没有任何有意义的“多线程”。也就是说，在任何时候都没有多个线程做有意义的工作。

    您的任务正在按顺序执行，因此没有理由启动多个线程让它们运行。

    如果您刚写完，那么您的代码会更清晰，执行速度会更快（因为不必启动这么多线程）：

    ThreadPool.QueueUserWorkItem((obj0) =>
{
    DownloadString(...); // NOT DownloadStringAsync
    DownloadString(...);
    // Do calculation
});

    一个线程按顺序执行每个任务。

    您需要多个线程的唯一时间是您希望同时执行多个任务。显然，这不是你正在做的事情。事实上，你的问题是：

      

    然后我有一个方法创建另一个线程来顺序执行一些计算，这是，我需要前一个线程的结果继续下面的一个。

    顺序任务意味着一个线程。

答案 1 :(得分：2)

我是否可以建议您将Reactive Extensions（Rx）视为在Silverlight中使用多线程的替代方法？

这是你在Rx中完成的代码：

Func<int, int, int> calculation = (n1, n2) =>
{
    var r = n1 + n2;
    r *= r;
    r *= 2;
    return r;
};

var query =
    from callid in Observable.Range(0, 6, Scheduler.ThreadPool)
    let n1 = rand.Next(10)
    let n2 = rand.Next(10)
    from result in Observable.Start(() => calculation(n1, n2))
    select new { callid, n1, n2, result };

query.Subscribe(x => { /* do something with result */ });

它会自动将计算推送到线程池中 - 我将Scheduler.ThreadPool参数放入，但它是SelectMany查询的默认值。

使用这种代码，您通常不必担心所有MRE，并且可以非常轻松地读取可以更轻松地进行测试的代码。

Rx是受支持的Microsoft产品，可在桌面CLR和Silverlight上运行。

以下是Rx的链接：

哦，我认为你获得非常不同的性能结果的原因是Silverlight只有毫秒级的分辨率，所以你真的必须运行数千次计算以获得良好的平均值。 / p>

编辑：根据评论中的请求，以下是使用Rx链接每个中间计算结果的示例。

Func<int, int, int> fn1 = (n1, n2) => n1 + n2;
Func<int, int> fn2 = n => n * n;
Func<int, int> fn3 = n => 2 * n;

var query =
    from callid in Observable.Range(0, 6, Scheduler.ThreadPool)
    let n1 = rand.Next(10)
    let n2 = rand.Next(10)
    from r1 in Observable.Start(() => fn1(n1, n2))
    from r2 in Observable.Start(() => fn2(r1))
    from r3 in Observable.Start(() => fn3(r2))
    select new { callid, n1, n2, r1, r2, r3 };

当然，三个lambda函数可以很容易地成为常规方法函数。

另一种选择，如果您使用BeginInvoke / EndInvoke异步模式的函数，则使用FromAsyncPattern扩展方法，如下所示：

Func<int, int, IObservable<int>> ofn1 =
    Observable.FromAsyncPattern<int, int, int>
        (fn1.BeginInvoke, fn1.EndInvoke);

Func<int, IObservable<int>> ofn2 =
    Observable.FromAsyncPattern<int, int>
        (fn2.BeginInvoke, fn2.EndInvoke);

Func<int, IObservable<int>> ofn3 =
    Observable.FromAsyncPattern<int, int>
        (fn3.BeginInvoke, fn3.EndInvoke);

var query =
    from callid in Observable.Range(0, 6, Scheduler.ThreadPool)
    let n1 = rand.Next(10)
    let n2 = rand.Next(10)
    from r1 in ofn1(n1, n2)
    from r2 in ofn2(r1)
    from r3 in ofn3(r2)
    select new { callid, n1, n2, r1, r2, r3 };

前面有点杂乱，但查询有点简单。

注意：同样，Scheduler.ThreadPool参数是不必要的，但只是包含在内以明确显示使用线程池执行查询。

相关问题
最新问题