FilesExpand file tree

 redis

/

AsyncLock.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

52 lines (44 loc) · 1.91 KB

 redis

/

AsyncLock.cs

Copy path

Top

File metadata and controls

• Code
• Blame

52 lines (44 loc) · 1.91 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

using System;

using System.Collections.Generic;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

namespace Medallion.Threading.Internal

{

/// <summary>

/// An async-based, <see cref="SyncOverAsync"/>-friendly mutex based on <see cref="SemaphoreSlim"/>. We don't expose a

/// <see cref="IDisposable.Dispose"/> method because <see cref="SemaphoreSlim"/> does not require disposal unless its

/// <see cref="SemaphoreSlim.AvailableWaitHandle"/> is accessed

/// </summary>

internal readonly struct AsyncLock

{

private readonly SemaphoreSlim _semaphore;

private AsyncLock(SemaphoreSlim semaphore)

{

this._semaphore = semaphore;

}

public static AsyncLock Create() => new AsyncLock(new SemaphoreSlim(initialCount: 1, maxCount: 1));

public async ValueTask<IDisposable> AcquireAsync(CancellationToken cancellationToken)

{

var handle = await this.TryAcquireAsync(Timeout.InfiniteTimeSpan, cancellationToken).ConfigureAwait(false);

Invariant.Require(handle != null);

return handle!;

}

public async ValueTask<IDisposable?> TryAcquireAsync(TimeoutValue timeout, CancellationToken cancellationToken)

{

var acquired = SyncOverAsync.IsSynchronous

? this._semaphore.Wait(timeout.InMilliseconds, cancellationToken)

: await this._semaphore.WaitAsync(timeout.InMilliseconds, cancellationToken).ConfigureAwait(false);

return acquired ? new Handle(this._semaphore) : null;

}

private sealed class Handle : IDisposable

{

private SemaphoreSlim? _semaphore;

public Handle(SemaphoreSlim semaphore)

{

this._semaphore = semaphore;

}

public void Dispose() => Interlocked.Exchange(ref this._semaphore, null)?.Release();

}

}

}