hangfire内部实验器是同步的，会导致死锁

再次碰到dotnet的第三方组件标题，就是hangfire的CoreBackgroundJobPerformer会导致死锁，它是作为hagnfire服务端的job实验器的，它非常的关键，是job可以或许运行的关键，这些库大概读是从很早的dotnetfremework期间移植过来的（我推测的），同样的存在同步调用异步代码的标题，会导致死锁。
它有标题的代码如下：

1. namespace Hangfire.Server
2. {
3.     internal sealed class CoreBackgroundJobPerformer : IBackgroundJobPerformer
4.     {
5.         private object InvokeMethod(PerformContext context, object instance, object[] arguments)
6.             if (context.BackgroundJob.Job == null) return null;
8.             try
9.             {
10.                 var methodInfo = context.BackgroundJob.Job.Method;
11.                 var method = new BackgroundJobMethod(methodInfo, instance, arguments);
12.                 var returnType = methodInfo.ReturnType;
14.                 if (returnType.IsTaskLike(out var getTaskFunc))
15.                 {
16.                     if (_taskScheduler != null)
17.                     {
18.                         return InvokeOnTaskScheduler(context, method, getTaskFunc);
19.                     }
21.                     return InvokeOnTaskPump(context, method, getTaskFunc);
22.                 }
24.                 return InvokeSynchronously(method);
25.             }
26.             catch (ArgumentException ex)
27.             {
28.                 HandleJobPerformanceException(ex, context.CancellationToken, context.BackgroundJob);
29.                 throw;
30.             }
31.             catch (AggregateException ex)
32.             {
33.                 HandleJobPerformanceException(ex.InnerException, context.CancellationToken, context.BackgroundJob);
34.                 throw;
35.             }
36.             catch (TargetInvocationException ex)
37.             {
38.                 HandleJobPerformanceException(ex.InnerException, context.CancellationToken, context.BackgroundJob);
39.                 throw;
40.             }
41.             catch (Exception ex) when (ex.IsCatchableExceptionType())
42.             {
43.                 HandleJobPerformanceException(ex, context.CancellationToken, context.BackgroundJob);
44.                 throw;
45.             }
46.         }
47.         private object InvokeOnTaskScheduler(PerformContext context, BackgroundJobMethod method, Func<object, Task> getTaskFunc)
48.         {
49.             var scheduledTask = Task.Factory.StartNew(
50.                 InvokeOnTaskSchedulerInternal,
51.                 method,
52.                 CancellationToken.None,
53.                 TaskCreationOptions.None,
54.                 _taskScheduler);
56.             var result = scheduledTask.GetAwaiter().GetResult();//同步执行异步
57.             if (result == null) return null;
59.             return getTaskFunc(result).GetTaskLikeResult(result, method.ReturnType);
60.         }
62.         private static object InvokeOnTaskSchedulerInternal(object state)
63.         {
64.             // ExecutionContext is captured automatically when calling the Task.Factory.StartNew
65.             // method, so we don't need to capture it manually. Please see the comment for
66.             // synchronous method execution below for details.
67.             return ((BackgroundJobMethod)state).Invoke();
68.         }
70.         private static object InvokeOnTaskPump(PerformContext context, BackgroundJobMethod method, Func<object, Task> getTaskFunc)
71.         {
72.             // Using SynchronizationContext here is the best default option, where workers
73.             // are still running on synchronous dispatchers, and where a single job performer
74.             // may be used by multiple workers. We can't create a separate TaskScheduler
75.             // instance of every background job invocation, because TaskScheduler.Id may
76.             // overflow relatively fast, and can't use single scheduler for multiple performers
77.             // for better isolation in the default case – non-default external scheduler should
78.             // be used. It's also great to preserve backward compatibility for those who are
79.             // using Parallel.For(Each), since we aren't changing the TaskScheduler.Current.
81.             var oldSyncContext = SynchronizationContext.Current;
83.             try
84.             {
85.                 using (var syncContext = new InlineSynchronizationContext())
86.                 using (var cancellationEvent = context.CancellationToken.ShutdownToken.GetCancellationEvent())
87.                 {
88.                     SynchronizationContext.SetSynchronizationContext(syncContext);
90.                     var result = InvokeSynchronously(method);
91.                     if (result == null) return null;
93.                     var task = getTaskFunc(result);
94.                     var asyncResult = (IAsyncResult)task;
96.                     var waitHandles = new[] { syncContext.WaitHandle, asyncResult.AsyncWaitHandle, cancellationEvent.WaitHandle };
98.                     while (!asyncResult.IsCompleted && WaitHandle.WaitAny(waitHandles) == 0)//这里也同样
99.                     {
100.                         var workItem = syncContext.Dequeue();
101.                         workItem.Item1(workItem.Item2);
102.                     }
104.                     return task.GetTaskLikeResult(result, method.ReturnType);
105.                 }
106.             }
107.             finally
108.             {
109.                 SynchronizationContext.SetSynchronizationContext(oldSyncContext);
110.             }
111.         }

复制代码

有标题的代码就是
var result = scheduledTask.GetAwaiter().GetResult();
以及
while (!asyncResult.IsCompleted && WaitHandle.WaitAny(waitHandles) == 0)
制止现在1.8.22版本照旧没有办理这个标题，有人提了issue了，但是要到2.0.0版本才会办理。

免责声明：如果侵犯了您的权益，请联系站长及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金.