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

技术群里有人发了一段代码：
附言：兄弟们，这个单例怎么样？

我回复：什么鬼，看不懂啊？！

也有其他小伙伴表示看不懂，看来大家的C#基础和我一样并不全面。

我看不懂，主要是因为我没用过TaskCompletionSource和Interlocked的CompareExchange方法，然后经过我1、2个小时的研究，终于勉强看懂了。

由于上面这段代码只贴了一张图，我没有拿到源码，所以我写了个差不多的Demo用于测试，代码如下：

复制代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SingletonTest
{
public class Singleton
{
private static Task _stringTask;

    /// <summary>
    /// 重置，方便重复测试
    /// </summary>
    public void Reset()
    {
        _stringTask = null;
    }

    public Task<string> InitAsync()
    {
        if (_stringTask != null)
        {
            return _stringTask;
        }

        var inition = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);

        var initonTask = Interlocked.CompareExchange(ref _stringTask, inition.Task, null);

        if (initonTask != null)
        {
            return initonTask;
        }

        _stringTask = CreateContent(inition);
        return inition.Task;
    }

    private async Task<string> CreateContent(TaskCompletionSource<string> inition)
    {
        string content = await TextUtil.GetTextAsync();
        inition.SetResult(content);
        return content;
    }
}

}
复制代码
然后按照我自己的习惯，又写了一版：

复制代码
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SingletonTest
{
class Singleton2
{
private static string _value;
private SemaphoreSlim _semaphoreSlim = new SemaphoreSlim(1, 1);

    /// <summary>
    /// 重置，方便重复测试
    /// </summary>
    public void Reset()
    {
        _value = null;
    }

    public async Task<string> InitAsync()
    {
        if (_value != null)
        {
            return _value;
        }

        await _semaphoreSlim.WaitAsync();
        if (_value == null)
        {
            _value = await TextUtil.GetTextAsync();
        }
        _semaphoreSlim.Release();

        return _value;
    }

}

}
复制代码
很容易懂，不是吗？

这段代码我好像是理解了，可是我不理解的是，为什么代码会写的这么复杂呢？

最主要的是我不理解下面几行：

复制代码
var inition = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);

var initonTask = Interlocked.CompareExchange(ref _stringTask, inition.Task, null);

if (initonTask != null)
{
return initonTask;
}
复制代码
我要给它翻译成我能理解的代码，我意思到new的TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously)也是个单例，所以我先写了个TaskCompletionSourceFactory类：

复制代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SingletonTest
{
public class TaskCompletionSourceFactory : IDisposable
{
private TaskCompletionSource _value;

    private TaskCompletionSourceData _data;

    private SemaphoreSlim _semaphoreSlim = new SemaphoreSlim(1, 1);

    public TaskCompletionSourceData Instance
    {
        get
        {
            _semaphoreSlim.Wait();
            if (_value == null)
            {
                _data = new TaskCompletionSourceData();
                _value = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
                _data.Value = _value;
                _data.First = true;
            }
            else
            {
                _data = new TaskCompletionSourceData();
                _data.Value = _value;
                _data.First = false;
            }
            _semaphoreSlim.Release();
            return _data;
        }
    }

    public void Dispose()
    {
        _semaphoreSlim.Dispose();
    }
}

public class TaskCompletionSourceData
{
    public bool First { get; set; }

    public TaskCompletionSource<string> Value { get; set; }
}

}
复制代码
然后把Demo中Singleton这个类改写了一下：

复制代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SingletonTest
{
public class Singleton3
{
private static Task _stringTask;

    /// <summary>
    /// 重置，方便重复测试
    /// </summary>
    public void Reset()
    {
        _stringTask = null;
    }

    public Task<string> InitAsync(TaskCompletionSourceFactory factory)
    {
        if (_stringTask != null)
        {
            return _stringTask;
        }

        var inition = factory.Instance;
        if (!inition.First)
        {
            return inition.Value.Task;
        }

        _stringTask = CreateContent(inition.Value);
        return inition.Value.Task;
    }

    private async Task<string> CreateContent(TaskCompletionSource<string> inition)
    {
        string content = await TextUtil.GetTextAsync();
        inition.SetResult(content);
        return content;
    }
}

}
复制代码
当我差不多理解了之后，我发现原始代码有一点点小问题，就是TaskCompletionSource是有机率被重复new的。

大家觉得哪种写法好呢？

附：

TextUtil.cs代码，是一个模拟获取文本的方法：

复制代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SingletonTest
{
public class TextUtil
{
public static Task GetTextAsync()
{
return Task.Run(() =>
{
Thread.Sleep(10);
Random rnd = new Random();
return rnd.Next(0, 1000).ToString().PadRight(10);
});
}
}
}
复制代码
测试代码：

复制代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SingletonTest
{
class Program
{
private static int _count = 200;
private static Singleton _singleton = new Singleton();
private static Singleton2 _singleton2 = new Singleton2();
private static Singleton3 _singleton3 = new Singleton3();

    static void Main(string[] args)
    {
        ThreadPool.SetMinThreads(20, 20);
        Task.Run(() => { }); //Task预热
        Console.WriteLine("输入1测试Singleton，输入2测试Singleton2，如果值都相同，说明单例测试通过，否则不通过");

        while (true)
        {
            var key = Console.ReadKey().Key;

            if (key == ConsoleKey.D1)
            {
                Console.WriteLine("测试Singleton");
                Test();
            }

            if (key == ConsoleKey.D2)
            {
                Console.WriteLine("测试Singleton2");
                Test2();
            }

            if (key == ConsoleKey.D3)
            {
                Console.WriteLine("测试Singleton3");
                Test3();
            }
        }

    }

    public static void Test()
    {
        List<Task> taskList = new List<Task>();
        for (int i = 0; i < _count; i++)
        {
            Task task = Task.Run(async () =>
            {
                string content = await _singleton.InitAsync();
                Console.Write(content);
            });
            taskList.Add(task);
        }

        Task.WaitAll(taskList.ToArray());
        _singleton.Reset();
        Console.WriteLine("");
    }

    public static void Test2()
    {
        List<Task> taskList = new List<Task>();
        for (int i = 0; i < _count; i++)
        {
            Task task = Task.Run(async () =>
            {
                string content = await _singleton2.InitAsync();
                Console.Write(content);
            });
            taskList.Add(task);
        }

        Task.WaitAll(taskList.ToArray());
        _singleton2.Reset();
        Console.WriteLine("");
    }

    public static void Test3()
    {
        TaskCompletionSourceFactory factory = new TaskCompletionSourceFactory();
        List<Task> taskList = new List<Task>();
        for (int i = 0; i < _count; i++)
        {
            Task task = Task.Run(async () =>
            {
                string content = await _singleton3.InitAsync(factory);
                Console.Write(content);
            });
            taskList.Add(task);
        }

        Task.WaitAll(taskList.ToArray());
        _singleton3.Reset();
        factory.Dispose();
        Console.WriteLine("");
    }
}

}