Semaphores.cs

using System;
using System.Threading.Tasks;
using Waher.Runtime.Cache;
using Waher.Runtime.Collections;
 
namespace Waher.Runtime.Threading
{
    public static class Semaphores
    {
        private static readonly Cache<string, MultiReadSingleWriteObject> semaphores;
 
        static Semaphores()
        {
            semaphores = new Cache<string, MultiReadSingleWriteObject>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromHours(1), true);
            semaphores.Removed += Semaphores_Removed;
        }
 
        private static Task Semaphores_Removed(object Sender, CacheItemEventArgs<string, MultiReadSingleWriteObject> e)
        {
            e.Value.Dispose();
 
            return Task.CompletedTask;
        }
 
        private static MultiReadSingleWriteObject GetSemaphore(string Key)
        {
            lock (semaphores)
            {
                if (semaphores.TryGetValue(Key, out MultiReadSingleWriteObject Result))
                    return Result;
 
                Result = new MultiReadSingleWriteObject(Key);
                semaphores[Key] = Result;
 
                return Result;
            }
        }
 
        public static async Task<Semaphore> BeginRead(string Key)
        {
            await GetSemaphore(Key).BeginRead();
            return new Semaphore(Key, 1);
        }
 
        public static Task EndRead(string Key)
        {
            return GetSemaphore(Key).EndRead();
        }
 
        public static Task<bool> TryBeginRead(string Key, int Timeout)
        {
            return GetSemaphore(Key).TryBeginRead(Timeout);
        }
 
        public static async Task<Semaphore> BeginWrite(string Key)
        {
            await GetSemaphore(Key).BeginWrite();
            return new Semaphore(Key, true);
        }
 
        public static Task EndWrite(string Key)
        {
            return GetSemaphore(Key).EndWrite();
        }
 
        public static Task<bool> TryBeginWrite(string Key, int Timeout)
        {
            return GetSemaphore(Key).TryBeginWrite(Timeout);
        }
 
        public static MultiReadSingleWriteObject[] FindLockedObjects(int MillisecondsThreshold)
        {
            return FindLockedObjects(MillisecondsThreshold, true);
        }
 
        public static MultiReadSingleWriteObject[] FindLockedObjects(int MillisecondsThreshold,
            bool OnlyIfWaitingTasks)
        {
            if (MillisecondsThreshold <= 0)
                throw new ArgumentOutOfRangeException("MilliSecondsThreshold must be greater than zero.", nameof(MillisecondsThreshold));
 
            ChunkedList<MultiReadSingleWriteObject> Result = new ChunkedList<MultiReadSingleWriteObject>();
 
            foreach (MultiReadSingleWriteObject Obj in semaphores.Values)
            {
                if (Obj.MillisecondsLocked > MillisecondsThreshold)
                {
                    if (OnlyIfWaitingTasks && Obj.QueueSize == 0)
                        continue;
 
                    Result.Add(Obj);
                }
            }
 
            return Result.ToArray();
        }
    }
}