7

我正在编写一个消耗资源的库，无论出于何种原因，API 的设计方式都是在不同的线程上引发事件，但 API 的调用必须在主线程上完成。

假设我尝试使用的 API 定义为（我将省略事件定义）：

public sealed class DodgyService
{
    public void MethodThatHasToBeCalledOnTheMainThread() { ... }
}

为了使用这个 API，我在我的库中添加了一个名为 Service 的服务（是的，非常原始的名称），它将创建一个新任务（当我指定一个从SynchronizationContext.

这是我的实现：

public class Service
{
  private readonly TaskFactory _taskFactory;
  private readonly TaskScheduler _mainThreadScheduler;

  public Service(TaskFactory taskFactory, TaskScheduler mainThreadScheduler)
  {
      _taskFactory = taskFactory;
      _mainThreadScheduler = mainThreadScheduler;
  }

  // Assume this method can be called from any thread.
  // In this sample is called by the main thread but most of the time
  // the caller will be running on a background thread.
  public Task ExecuteAsync(string taskName)
  {
      return _taskFactory.StartNew(
          () => ReallyLongCallThatForWhateverStupidReasonHasToBeCalledOnMainThread(taskName),
          new CancellationToken(false), TaskCreationOptions.None, _mainThreadScheduler)
          .ContinueWith(task => Trace.TraceInformation("ExecuteAsync has completed on \"{0}\"...", taskName));
  }

  private void ReallyLongCallThatForWhateverStupidReasonHasToBeCalledOnMainThread(string taskName)
  {
      Trace.TraceInformation("Starting \"{0}\" really long call...", taskName);
      new DodgyService().MethodThatHasToBeCalledOnTheMainThread();
      Trace.TraceInformation("Finished \"{0}\" really long call...", taskName);
  }

}

现在，如果我执行我的服务调用（在主线程上）并尝试在主线程上等待应用程序进入死锁，因为主线程将等待已安排在主线程上执行的任务。

如何在不阻塞整个进程的情况下将这些调用编组到主线程上？

在某些时候，我想在创建新任务之前执行主线程的检测，但我不想破解这个。

对于任何感兴趣的人，我在这里得到了一个要点，其中包含代码和一个展示该问题的 WPF 应用程序。

顺便说一句，该库必须在 .net framework 4.0 上编写

编辑！我按照此处提供的Scott Chamberlain提供的建议解决了我的问题

4

3 回答 3

8

因为主线程将等待任务

这是一个有保证的僵局。一个任务不能在主线程上执行，直到它空闲，运行调度程序循环（也就是泵送消息循环）。正是调度程序循环实现了让代码在特定线程上运行的魔力。然而，主线程不会空闲，它正在“等待任务”。所以任务不能完成，因为主线程不会空闲，主线程不能空闲，因为任务不会完成。死锁城。

您必须重写代码，以便您的主线程不会等待。将等待调用之后出现的任何代码移动到在主线程上运行的另一个任务，就像真正的 LongCall() 一样。

请注意，您似乎根本没有从使用任务中获得任何好处，您的代码段表明没有任何重要的代码在工作线程上运行。所以你不妨直接调用它，也能解决问题。

于 2013-11-11T22:53:06.587 回答
2

从您的示例程序中：

  private void HandleClosed(object sender, EventArgs e)
  {
      var list = new[]
      {
          _service.ExecuteAsync("first task"),
          _service.ExecuteAsync("second task"),
          _service.ExecuteAsync("third task")
      };

      //uncommenting this line blocks all three previous activities as expected
      //as it drives the current main thread to wait for other tasks waiting to be executed by the main thread.

      //Task.WaitAll(list);
  }

Task.WaitAll是阻塞调用，不能在主线程上执行阻塞调用，否则会导致死锁。您可以做的（如果您使用的是 Visual Studio 2012 或更新版本）是使用 NuGet 包Microsoft.Bcl.Async，它async/await支持 .Net 4.0。

添加包后将代码更改为

private async void HandleClosed(object sender, EventArgs e)
{
    var list = new[]
  {
      _service.ExecuteAsync("first task"),
      _service.ExecuteAsync("second task"),
      _service.ExecuteAsync("third task")
  };

    //uncommenting this line blocks all three previous activities as expected
    //as it drives the current main thread to wait for other tasks waiting to be executed by the main thread.

    await TaskEx.WhenAll(list);
}

并且您的程序将不再死锁（之后它也不会执行任何代码，await TaskEx.WhenAll(list);但那是因为此代码在关闭过程中运行，并且当您await让关闭继续处理时，如果它被放置在其他地方，例如单击事件，您会看到更正常的行为）。

另一种选择是拥有第二个“主线程”并将工作分派给该线程。通常，当必须在“主”线程上运行某些东西时，实际上是在说他们需要在“一个 STA Windows 消息泵送该对象最初是在“线程上创建的”上运行。这是一个示例（取自此处）

private void runBrowserThread(Uri url) {
    var th = new Thread(() => {
        var br = new WebBrowser();
        br.DocumentCompleted += browser_DocumentCompleted;
        br.Navigate(url);
        Application.Run();
    });
    th.SetApartmentState(ApartmentState.STA);
    th.Start();
}

void browser_DocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e) {
    var br = sender as WebBrowser;
    if (br.Url == e.Url) {
        Console.WriteLine("Natigated to {0}", e.Url);
        Application.ExitThread();   // Stops the thread
    }
}
于 2013-11-11T22:54:54.477 回答
0

@HansPassant 是正确的；通过阻止调度程序线程等待任务，您可以防止任务被执行。您可能做出的最简单的更改是替换Task.WaitAll(list)为：

_taskFactory.ContinueWhenAll(
    list,
    tasks => { /* resume here */ });

...然后将调用后的任何代码移动WaitAll()到继续。请记住检查任务结果并对可能发生的任何异常做出适当的响应。

但是，除非使用您的示例代码中不明显的任务有一些切实的好处，否则我会听从 Hans 的建议并简单地放弃任务以支持同步调用。

于 2013-11-12T01:26:02.387 回答