2019-12-1-实现一种异步版本的AutoResetEvent

黄腾霄

发布于 2020-06-10 14:55:30

5540

发布于 2020-06-10 14:55:30

文章被收录于专栏：黄腾霄的博客

我们在2019-12-1-实现一种异步版本的ManualResetEvent - huangtengxiao给大家介绍了异步版本的ManualResetEvent。这里我们自己实现一个异步版本的AutoResetEvent

这里是我们创建的异步版本的AutoResetEvent。

实现方式和之前的异步版本ManualResetEvent基本相同，也是使用了一个TaskCompletionSource。

    public class AutoResetEventAsync
    {
        /// <summary>
        /// 提供一个信号初始值，确定是否有信号
        /// </summary>
        /// <param name="initialState">true为有信号，所有等待可以直接通过</param>
        public AutoResetEventAsync(bool initialState)
        {
            _isSignaled = initialState;
        }

        /// <summary>
        /// 异步等待一个信号，需要await
        /// </summary>
        /// <returns></returns>
        public Task WaitOneAsync()
        {
            lock (_locker)
            {
                if (_isSignaled)
                {
                    _isSignaled = false;
                    return CompletedSourceTask;
                }

                var source = new TaskCompletionSource<bool>();
                _waitQueue.Enqueue(source);
                return source.Task;
            }
        }

        /// <summary>
        /// 设置一个信号量，让一个waitone获得信号
        /// </summary>
        public void Set()
        {
            TaskCompletionSource<bool> releaseSource = null;
            lock (_locker)
            {
                if (_waitQueue.Any())
                {
                    releaseSource = _waitQueue.Dequeue();
                }

                if (releaseSource is null)
                {
                    if (!_isSignaled)
                    {
                        _isSignaled = true;
                    }
                }
            }

            releaseSource?.SetResult(true);
        }

        private static readonly Task CompletedSourceTask = Task.FromResult(true);

        private readonly Queue<TaskCompletionSource<bool>> _waitQueue =
            new Queue<TaskCompletionSource<bool>>();

        private bool _isSignaled;

        private readonly object _locker = new object();

分析下上述代码。首先AutoResetEvent一次只能有一个对象获得信号量。信号量被获取后马上会被reset。

那么我们就不能一直使用同一个TaskCompletionSource进行等待。所以我们添加了一个队列维持TaskCompletionSource对象。每次调用WaitOneAsync的时候就返回一个TaskCompletionSource的新实例。

当然在Signal的情况下可以使用Task.FromResult直接返回一个被标记完成的task，避免等待。

而每次调用set的时候，依次从队列里面出列，然后调用SetResult将其标记为完成。此时对应的task可以继续执行。

分析

不过可以注意到上面的代码都是先调用WaitOneAsync的方法先得到返回。而AutoResetEvent在set时，获得同步锁的线程是随机的。

这里实际上无伤大雅，因为顺序也是随机的一种情况，在使用AutoResetEvent本身就不应该依赖顺序。当然，如果你觉得不妥，可以将队列改为List，并且在set方法中通过随机数，选择一个实例进行标记，以达到模拟随机的效果。

另外，我们在2019-12-1-使用SemaphoreSlim实现异步等待 - huangtengxiao中提到的SemaphoreSlim对象将最大并发数设置为1时，完全可以实现异步版本的AutoResetEvent效果。而且在长期等待的情况下性能会更好（因为SemaphoreSlim可以进入内核态等待）

实现代码如下：

    public class AutoResetEventAsync2
    {
        /// <summary>
        /// 提供一个信号初始值，确定是否有信号
        /// </summary>
        /// <param name="initialState">true为有信号，所有等待可以直接通过</param>
        public AutoResetEventAsync2(bool initialState)
        {
            var state = initialState?:;
            _semaphoreSlim = new SemaphoreSlim(state,);
        }

        /// <summary>
        /// 异步等待一个信号，需要await
        /// </summary>
        /// <returns></returns>
        public async Task WaitOneAsync()
        {
            await _semaphoreSlim.WaitAsync();
        }

        /// <summary>
        /// 设置一个信号量，让一个waitone获得信号
        /// </summary>
        public void Set()
        {
            _semaphoreSlim.Release();
        }
    

        private SemaphoreSlim _semaphoreSlim;

参考文档：