(译)构建Async同步基元,Part 6 AsyncLock

传送门:异步编程系列目录……

最近在学习.NET4.5关于“并行任务”的使用。“并行任务”有自己的同步机制,没有显示给出类似如旧版本的:事件等待句柄、信号量、lockReaderWriterLock……等同步基元对象,但我们可以沿溪这一编程习惯,那么这系列翻译就是给“并行任务”封装同步基元对象。翻译资源来源《(译)关于AsyncAwaitFAQ

1.         构建Async同步基元,Part 1 AsyncManualResetEvent

2.         构建Async同步基元,Part 2 AsyncAutoResetEvent

3.         构建Async同步基元,Part 3 AsyncCountdownEvent

4.         构建Async同步基元,Part 4 AsyncBarrier

5.         构建Async同步基元,Part 5 AsyncSemaphore

6.         构建Async同步基元,Part 6 AsyncLock

7.         构建Async同步基元,Part 7 AsyncReaderWriterLock

 

源码:构建Async同步基元.rar

开始:构建Async同步基元,Part 6 AsyncLock

         最近,我们刚刚构建了一个AsyncSemphore,现在,我们来构建一个在using块中支持异步互斥机制的类型。

         正如前面帖子所述,信号量非常适用于限流及资源访问管理。你可以给信号量一个初始计数,然后它将只允许指定数量的消费者成功获得信号,强迫多余的请求等待直到资源被释放内部信号计数大于0信号量可以用来保护正确进入特定代码区域,并且内部计数可以设置为1。通过这种方式,你能使用信号量来达到互斥目的,比如:

private readonly AsyncSemaphore m_lock = new AsyncSemaphore(1); 
… 
await m_lock.WaitAsync(); 
try 
{ 
    … // protected code here 
}  
finally
{ 
    m_lock.Release();
}

         我们可以通过创建一个AsyncLock类型来支持使用using关键字来简化编码。我们的目的是和上面片段一致的,但是通过类似下面的代码来实现:

private readonly AsyncLock m_lock = new AsyncLock(); 
… 
using(var releaser = await m_lock.LockAsync()) 
{ 
    … // protected code here 
}

为了达到这样的效果,我们将构建下面这样的类型:

public class AsyncLock 
{ 
    public AsyncLock();
    public Task<Releaser> LockAsync();
    public struct Releaser : IDisposable 
    { 
        public void Dispose(); 
    } 
}

在内部,我们将维护两个成员。我们使用AsyncSemaphore对象来处理大部分逻辑,使用m_releaser变量缓存的Task<Releaser>实例,当访问的锁没有竞争时,可以直接返回从而避免不必要的分配。

private readonly AsyncSemaphore m_semaphore; 
private readonly Task<Releaser> m_releaser;

Releaser结构仅仅是实现了IDisposable接口的Dispose()方法,该方法将释放底层的信号量。这是允许我们在using块中使用Releaser构造的原因,由using自动生成的finally块将调用Dispose()方法,即Seamphore实例的Release()方法来进行释放。

public struct Releaser : IDisposable 
{ 
    private readonly AsyncLock m_toRelease; 
    internal Releaser(AsyncLock toRelease)
    { 
        m_toRelease = toRelease; 
    } 

    public void Dispose() 
    { 
        if (m_toRelease != null) 
            m_toRelease.m_semaphore.Release(); 
    } 
}

我们的AsyncLock的构造函数仅仅是初始化成员,使用数值为1的参数创建一个Semaphore,并且创建一个缓存的Task<Releaser>

public AsyncLock() 
{ 
    m_semaphore = new AsyncSemaphore(1); 
    m_releaser = Task.FromResult(new Releaser(this)); 
}

最后,构建我们的LockAsync方法。我们首先调用SemaphoreWaitAsync()获得一个Task,用于指代我们获得的锁。如果Task已经完成,则同步返回缓存的Task<Releaser>,这也意味着如果锁没有竞争就不需要分配。如果Task没有完成,则返回一个Task<Releaser>的延续任务。

public Task<Releaser> LockAsync() 
{ 
    var wait = m_semaphore.WaitAsync(); 
    return wait.IsCompleted ? 
        m_releaser : 
        wait.ContinueWith((_,state) => new Releaser((AsyncLock)state), 
            this, CancellationToken.None, 
            TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default); 
}

 

这就是本节要讲的AsyncLock

完整源码如下:

    public class AsyncLock
    {
        private readonly AsyncSemaphore m_semaphore;
        // 缓存Task<Releaser>实例,当访问的锁没有竞争时,可以直接返回从而避免不必要的分配。
        private readonly Task<Releaser> m_releaser;

        public AsyncLock()
        {
            // 信号量为1,用于实现互斥
            m_semaphore = new AsyncSemaphore(1);
            m_releaser = Task.FromResult(new Releaser(this));
        }

        public Task<Releaser> LockAsync()
        {
            var wait = m_semaphore.WaitAsync();
            return wait.IsCompleted ?
                m_releaser :
                wait.ContinueWith((_, state) => new Releaser((AsyncLock)state)
                , this, CancellationToken.None
                , TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
        }

        public struct Releaser : IDisposable
        {
            private readonly AsyncLock m_toRelease;
            internal Releaser(AsyncLock toRelease)
            {
                m_toRelease = toRelease;
            }
            // using块生成的finally块调用IDisposable接口的Dispose()方法
            public void Dispose()
            {
                if (m_toRelease != null)
                    m_toRelease.m_semaphore.Release();

            }
        }
    }

    /// <summary>
    /// 使用方式
    /// </summary>
    public class AsyncLock_Test
    {
        private readonly AsyncLock m_lock = new AsyncLock();
        public async void Test()
        {
            using (var releaser = await m_lock.LockAsync())
            {
                // 限制访问代码
            }
        }
    }

 

下一节,我将实现一个异步版本的 read/writer 锁。

                                                                                                                

推荐阅读:

                   异步编程:同步基元对象(上)

                   异步编程:同步基元对象(下)

 

感谢你的观看……

原文:Building Async Coordination Primitives, Part 6: AsyncLock

作者:Stephen Toub – MSFT

 

转载于:https://www.cnblogs.com/heyuquan/archive/2013/01/16/2863094.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
疫情居家办公系统管理系统按照操作主体分为管理员和用户。管理员的功能包括办公设备管理、部门信息管理、字典管理、公告信息管理、请假信息管理、签到信息管理、留言管理、外出报备管理、薪资管理、用户管理、公司资料管理、管理员管理。用户的功能等。该系统采用了MySQL数据库,Java语言,Spring Boot框架等技术进行编程实现。 疫情居家办公系统管理系统可以提高疫情居家办公系统信息管理问题的解决效率,优化疫情居家办公系统信息处理流程,保证疫情居家办公系统信息数据的安全,它是一个非常可靠,非常安全的应用程序。 管理员权限操作的功能包括管理公告,管理疫情居家办公系统信息,包括外出报备管理,培训管理,签到管理,薪资管理等,可以管理公告。 外出报备管理界面,管理员在外出报备管理界面中可以对界面中显示,可以对外出报备信息的外出报备状态进行查看,可以添加新的外出报备信息等。签到管理界面,管理员在签到管理界面中查看签到种类信息,签到描述信息,新增签到信息等。公告管理界面,管理员在公告管理界面中新增公告,可以删除公告。公告类型管理界面,管理员在公告类型管理界面查看公告的工作状态,可以对公告的数据进行导出,可以添加新公告的信息,可以编辑公告信息,删除公告信息
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值