为什么有的人把代码写的如此复杂？

技术群里有人发了一段代码：

附言：兄弟们，这个单例怎么样？
我回复：什么鬼，看不懂啊？！
也有其他小伙伴表示看不懂，看来大家的C#基础和我一样并不全面。
我看不懂，主要是因为我没用过TaskCompletionSource和Interlocked的CompareExchange方法，然后经过我1、2个小时的研究，终于勉强看懂了。
由于上面这段代码只贴了一张图，我没有拿到源码，所以我写了个差不多的Demo用于测试，代码如下：

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Threading;
6. using System.Threading.Tasks;
8. namespace SingletonTest
9. {
10.     public class Singleton
11.     {
12.         private static Task<string> _stringTask;
14.         /// <summary>
15.         /// 重置，方便重复测试
16.         /// </summary>
17.         public void Reset()
18.         {
19.             _stringTask = null;
20.         }
22.         public Task<string> InitAsync()
23.         {
24.             if (_stringTask != null)
25.             {
26.                 return _stringTask;
27.             }
29.             var inition = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
31.             var initonTask = Interlocked.CompareExchange(ref _stringTask, inition.Task, null);
33.             if (initonTask != null)
34.             {
35.                 return initonTask;
36.             }
38.             _stringTask = CreateContent(inition);
39.             return inition.Task;
40.         }
42.         private async Task<string> CreateContent(TaskCompletionSource<string> inition)
43.         {
44.             string content = await TextUtil.GetTextAsync();
45.             inition.SetResult(content);
46.             return content;
47.         }
48.     }
49. }

复制代码

View Code然后按照我自己的习惯，又写了一版：

1. using System;
2. using System.Collections.Concurrent;
3. using System.Collections.Generic;
4. using System.Linq;
5. using System.Text;
6. using System.Threading;
7. using System.Threading.Tasks;
9. namespace SingletonTest
10. {
11.     class Singleton2
12.     {
13.         private static string _value;
14.         private SemaphoreSlim _semaphoreSlim = new SemaphoreSlim(1, 1);
16.         /// <summary>
17.         /// 重置，方便重复测试
18.         /// </summary>
19.         public void Reset()
20.         {
21.             _value = null;
22.         }
24.         public async Task<string> InitAsync()
25.         {
26.             if (_value != null)
27.             {
28.                 return _value;
29.             }
31.             await _semaphoreSlim.WaitAsync();
32.             if (_value == null)
33.             {
34.                 _value = await TextUtil.GetTextAsync();
35.             }
36.             _semaphoreSlim.Release();
38.             return _value;
39.         }
41.     }
42. }

复制代码

View Code很容易懂，不是吗？ 
这段代码我好像是理解了，可是我不理解的是，为什么代码会写的这么复杂呢？
最主要的是我不理解下面几行：

1. var inition = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
3. var initonTask = Interlocked.CompareExchange(ref _stringTask, inition.Task, null);
5. if (initonTask != null)
6. {
7.     return initonTask;
8. }

复制代码

View Code我要给它翻译成我能理解的代码，我意思到new的TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously)也是个单例，所以我先写了个TaskCompletionSourceFactory类：

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Threading;
6. using System.Threading.Tasks;
8. namespace SingletonTest
9. {
10.     public class TaskCompletionSourceFactory : IDisposable
11.     {
12.         private TaskCompletionSource<string> _value;
14.         private TaskCompletionSourceData _data;
16.         private SemaphoreSlim _semaphoreSlim = new SemaphoreSlim(1, 1);
18.         public TaskCompletionSourceData Instance
19.         {
20.             get
21.             {
22.                 _semaphoreSlim.Wait();
23.                 if (_value == null)
24.                 {
25.                     _data = new TaskCompletionSourceData();
26.                     _value = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
27.                     _data.Value = _value;
28.                     _data.First = true;
29.                 }
30.                 else
31.                 {
32.                     _data = new TaskCompletionSourceData();
33.                     _data.Value = _value;
34.                     _data.First = false;
35.                 }
36.                 _semaphoreSlim.Release();
37.                 return _data;
38.             }
39.         }
41.         public void Dispose()
42.         {
43.             _semaphoreSlim.Dispose();
44.         }
45.     }
47.     public class TaskCompletionSourceData
48.     {
49.         public bool First { get; set; }
51.         public TaskCompletionSource<string> Value { get; set; }
52.     }
53. }

复制代码

View Code然后把Demo中Singleton这个类改写了一下：

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Threading;
6. using System.Threading.Tasks;
8. namespace SingletonTest
9. {
10.     public class Singleton3
11.     {
12.         private static Task<string> _stringTask;
14.         /// <summary>
15.         /// 重置，方便重复测试
16.         /// </summary>
17.         public void Reset()
18.         {
19.             _stringTask = null;
20.         }
22.         public Task<string> InitAsync(TaskCompletionSourceFactory factory)
23.         {
24.             if (_stringTask != null)
25.             {
26.                 return _stringTask;
27.             }
29.             var inition = factory.Instance;
30.             if (!inition.First)
31.             {
32.                 return inition.Value.Task;
33.             }
35.             _stringTask = CreateContent(inition.Value);
36.             return inition.Value.Task;
37.         }
39.         private async Task<string> CreateContent(TaskCompletionSource<string> inition)
40.         {
41.             string content = await TextUtil.GetTextAsync();
42.             inition.SetResult(content);
43.             return content;
44.         }
45.     }
46. }

复制代码

View Code当我差不多理解了之后，我发现原始代码有一点点小问题，就是TaskCompletionSource是有机率被重复new的。
大家觉得哪种写法好呢？
附：
TextUtil.cs代码，是一个模拟获取文本的方法：

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Threading;
6. using System.Threading.Tasks;
8. namespace SingletonTest
9. {
10.     public class TextUtil
11.     {
12.         public static Task<string> GetTextAsync()
13.         {
14.             return Task.Run<string>(() =>
15.             {
16.                 Thread.Sleep(10);
17.                 Random rnd = new Random();
18.                 return rnd.Next(0, 1000).ToString().PadRight(10);
19.             });
20.         }
21.     }
22. }

复制代码

View Code测试代码：

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Threading;
6. using System.Threading.Tasks;
8. namespace SingletonTest
9. {
10.     class Program
11.     {
12.         private static int _count = 200;
13.         private static Singleton _singleton = new Singleton();
14.         private static Singleton2 _singleton2 = new Singleton2();
15.         private static Singleton3 _singleton3 = new Singleton3();
17.         static void Main(string[] args)
18.         {
19.             ThreadPool.SetMinThreads(20, 20);
20.             Task.Run(() => { }); //Task预热
21.             Console.WriteLine("输入1测试Singleton，输入2测试Singleton2，如果值都相同，说明单例测试通过，否则不通过");
23.             while (true)
24.             {
25.                 var key = Console.ReadKey().Key;
27.                 if (key == ConsoleKey.D1)
28.                 {
29.                     Console.WriteLine("测试Singleton");
30.                     Test();
31.                 }
33.                 if (key == ConsoleKey.D2)
34.                 {
35.                     Console.WriteLine("测试Singleton2");
36.                     Test2();
37.                 }
39.                 if (key == ConsoleKey.D3)
40.                 {
41.                     Console.WriteLine("测试Singleton3");
42.                     Test3();
43.                 }
44.             }
46.         }
48.         public static void Test()
49.         {
50.             List<Task> taskList = new List<Task>();
51.             for (int i = 0; i < _count; i++)
52.             {
53.                 Task task = Task.Run(async () =>
54.                 {
55.                     string content = await _singleton.InitAsync();
56.                     Console.Write(content);
57.                 });
58.                 taskList.Add(task);
59.             }
61.             Task.WaitAll(taskList.ToArray());
62.             _singleton.Reset();
63.             Console.WriteLine("");
64.         }
66.         public static void Test2()
67.         {
68.             List<Task> taskList = new List<Task>();
69.             for (int i = 0; i < _count; i++)
70.             {
71.                 Task task = Task.Run(async () =>
72.                 {
73.                     string content = await _singleton2.InitAsync();
74.                     Console.Write(content);
75.                 });
76.                 taskList.Add(task);
77.             }
79.             Task.WaitAll(taskList.ToArray());
80.             _singleton2.Reset();
81.             Console.WriteLine("");
82.         }
84.         public static void Test3()
85.         {
86.             TaskCompletionSourceFactory factory = new TaskCompletionSourceFactory();
87.             List<Task> taskList = new List<Task>();
88.             for (int i = 0; i < _count; i++)
89.             {
90.                 Task task = Task.Run(async () =>
91.                 {
92.                     string content = await _singleton3.InitAsync(factory);
93.                     Console.Write(content);
94.                 });
95.                 taskList.Add(task);
96.             }
98.             Task.WaitAll(taskList.ToArray());
99.             _singleton3.Reset();
100.             factory.Dispose();
101.             Console.WriteLine("");
102.         }
103.     }
104. }

复制代码

View Code 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！