在同步方法中使用Task.Run（）以避免异步方法等待死锁？

5 回答

• 2

  您似乎了解了问题中涉及的风险，因此我将跳过讲座 .

  要回答你的实际问题：是的，你可以使用 Task.Run 将该工作卸载到没有 SynchronizationContext 的 ThreadPool 线程，因此没有真正的死锁风险 .

  However ，使用另一个线程只是因为它没有SC有点像黑客并且可能是一个昂贵的，因为在 ThreadPool 上完成的工作安排有其成本 .

  一个更好，更清晰的解决方案IMO将暂时使用 SynchronizationContext.SetSynchronizationContext 删除SC并在之后恢复它 . 这可以很容易地封装到 IDisposable 中，因此您可以在 using 范围内使用它：

  public static class NoSynchronizationContextScope
  {
      public static Disposable Enter()
      {
          var context = SynchronizationContext.Current;
          SynchronizationContext.SetSynchronizationContext(null);
          return new Disposable(context);
      }
  
      public struct Disposable : IDisposable
      {
          private readonly SynchronizationContext _synchronizationContext;
  
          public Disposable(SynchronizationContext synchronizationContext)
          {
              _synchronizationContext = synchronizationContext;
          }
  
          public void Dispose() =>
              SynchronizationContext.SetSynchronizationContext(_synchronizationContext);
      }
  }
  

  用法：

  private void MySynchronousMethodLikeDisposeForExample()
  {
      using (NoSynchronizationContextScope.Enter())
      {
          MyAsyncMethod().Wait();
      }
  }
  

  回复于 2024-04-24T00:36:06+08:00
• 1

  这个代码不会因为你在问题中突出显示的原因而死锁 - 代码总是在没有同步上下文的情况下运行（因为使用线程池），而 Wait 将简单地阻塞线程直到/ if方法返回 .

  回复于 2024-04-24T00:36:06+08:00
• 2

  当我必须同步调用异步方法并且线程可以是UI线程时，这是我避免死锁的方法：

  public static T GetResultSafe<T>(this Task<T> task)
      {
          if (SynchronizationContext.Current == null)
              return task.Result;
  
          if (task.IsCompleted)
              return task.Result;
  
          var tcs = new TaskCompletionSource<T>();
          task.ContinueWith(t =>
          {
              var ex = t.Exception;
              if (ex != null)
                  tcs.SetException(ex);
              else
                  tcs.SetResult(t.Result);
          }, TaskScheduler.Default);
  
          return tcs.Task.Result;
      }
  

  回复于 2024-04-24T00:36:06+08:00
• 1

  使用小型自定义同步上下文，同步功能可以等待异步功能的完成，而不会产生死锁 . 原始线程被保留，因此sync方法在调用异步函数之前和之后使用相同的线程 . 这是WinForms应用程序的一个小例子 .

  Imports System.Threading
  Imports System.Runtime.CompilerServices
  
  Public Class Form1
  
      Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
          SyncMethod()
      End Sub
  
      ' waiting inside Sync method for finishing async method
      Public Sub SyncMethod()
          Dim sc As New SC
          sc.WaitForTask(AsyncMethod())
          sc.Release()
      End Sub
  
      Public Async Function AsyncMethod() As Task(Of Boolean)
          Await Task.Delay(1000)
          Return True
      End Function
  
  End Class
  
  Public Class SC
      Inherits SynchronizationContext
  
      Dim OldContext As SynchronizationContext
      Dim ContextThread As Thread
  
      Sub New()
          OldContext = SynchronizationContext.Current
          ContextThread = Thread.CurrentThread
          SynchronizationContext.SetSynchronizationContext(Me)
      End Sub
  
      Dim DataAcquired As New Object
      Dim WorkWaitingCount As Long = 0
      Dim ExtProc As SendOrPostCallback
      Dim ExtProcArg As Object
  
      <MethodImpl(MethodImplOptions.Synchronized)>
      Public Overrides Sub Post(d As SendOrPostCallback, state As Object)
          Interlocked.Increment(WorkWaitingCount)
          Monitor.Enter(DataAcquired)
          ExtProc = d
          ExtProcArg = state
          AwakeThread()
          Monitor.Wait(DataAcquired)
          Monitor.Exit(DataAcquired)
      End Sub
  
      Dim ThreadSleep As Long = 0
  
      Private Sub AwakeThread()
          If Interlocked.Read(ThreadSleep) > 0 Then ContextThread.Resume()
      End Sub
  
      Public Sub WaitForTask(Tsk As Task)
          Dim aw = Tsk.GetAwaiter
  
          If aw.IsCompleted Then Exit Sub
  
          While Interlocked.Read(WorkWaitingCount) > 0 Or aw.IsCompleted = False
              If Interlocked.Read(WorkWaitingCount) = 0 Then
                  Interlocked.Increment(ThreadSleep)
                  ContextThread.Suspend()
                  Interlocked.Decrement(ThreadSleep)
              Else
                  Interlocked.Decrement(WorkWaitingCount)
                  Monitor.Enter(DataAcquired)
                  Dim Proc = ExtProc
                  Dim ProcArg = ExtProcArg
                  Monitor.Pulse(DataAcquired)
                  Monitor.Exit(DataAcquired)
                  Proc(ProcArg)
              End If
          End While
  
      End Sub
  
       Public Sub Release()
           SynchronizationContext.SetSynchronizationContext(OldContext)
       End Sub
  
  End Class
  

  回复于 2024-04-24T00:36:06+08:00
• 51

  如果绝对必须从同步方法调用异步方法，请确保在异步方法调用中使用 ConfigureAwait(false) 以避免捕获同步上下文 .

  这应该成立，但充其量只是摇摇欲坠 . 我建议考虑重构 . 代替 .

  回复于 2024-04-24T00:36:06+08:00