FifoSemaphore.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
 
namespace Tgstation.Server.Host.Utils
{
    sealed class FifoSemaphore : IDisposable
    {
        sealed class FifoSemaphoreTicket
        {
            public bool Abandoned { get; set; }
        }
 
        readonly SemaphoreSlim semaphore;
 
        readonly Queue<FifoSemaphoreTicket> ticketQueue;
 
        public FifoSemaphore()
        {
            ticketQueue = new Queue<FifoSemaphoreTicket>();
            semaphore = new SemaphoreSlim(1);
        }
 
        public void Dispose() => semaphore.Dispose();
 
        public async ValueTask<SemaphoreSlimContext> Lock(CancellationToken cancellationToken)
        {
            FifoSemaphoreTicket? ticket = null;
            using (cancellationToken.Register(
                () =>
                {
                    if (ticket != null)
                        ticket.Abandoned = true;
                }))
                while (true)
                {
                    var context = await SemaphoreSlimContext.Lock(semaphore, cancellationToken);
                    try
                    {
                        FifoSemaphoreTicket? peekedTicket = null;
                        while (ticketQueue.Count > 0)
                        {
                            peekedTicket = ticketQueue.Peek();
                            if (peekedTicket.Abandoned)
                                ticketQueue.Dequeue();
                            else
                                break;
                        }
 
                        cancellationToken.ThrowIfCancellationRequested();
 
                        bool goTime;
                        if (ticketQueue.Count == 0)
                            goTime = true;
                        else if (ticket == null)
                        {
                            ticket = new FifoSemaphoreTicket();
                            cancellationToken.ThrowIfCancellationRequested();
                            ticketQueue.Enqueue(ticket);
                            goTime = false;
                        }
                        else
                        {
                            goTime = peekedTicket == ticket;
                            if (goTime)
                                ticketQueue.Dequeue();
                        }
 
                        if (goTime)
                        {
                            var localContext = context;
                            context = null;
                            return localContext;
                        }
                    }
                    finally
                    {
                        context?.Dispose();
                    }
 
                    await Task.Yield();
                }
        }
    }
}