MultiReadSingleWriteObject.cs

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
 
namespace Waher.Runtime.Threading
{
    public class MultiReadSingleWriteObject : IMultiReadSingleWriteObject, IDisposable
    {
#if DEBUG
        private readonly string creatorStacktrace;
#endif
        private readonly object owner;
        private LinkedList<TaskCompletionSource<bool>> noWriters = new LinkedList<TaskCompletionSource<bool>>();
        private LinkedList<TaskCompletionSource<bool>> noReadersOrWriters = new LinkedList<TaskCompletionSource<bool>>();
        private readonly object synchObj = new object();
        private long token = 0;
        private int nrReaders = 0;
        private bool isWriting = false;
 
        public MultiReadSingleWriteObject(object Owner)
            : this()
        {
            this.owner = Owner;
        }
 
        public MultiReadSingleWriteObject()
        {
#if DEBUG
            this.creatorStacktrace = Environment.StackTrace;
#endif
        }
 
        public object Owner => this.owner;
 
#if DEBUG
        public string CreatorStacktrace => this.creatorStacktrace;
#endif
 
        public int NrReaders
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.nrReaders;
                }
            }
        }
 
        public bool IsReading
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.nrReaders > 0;
                }
            }
        }
 
        public bool IsWriting
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.isWriting;
                }
            }
        }
 
        public bool IsReadingOrWriting
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.nrReaders > 0 || this.isWriting;
                }
            }
        }
 
        public void AssertReading()
        {
            lock (this.synchObj)
            {
                if (this.nrReaders <= 0)
                    throw new InvalidOperationException("Not in a reading state.");
            }
        }
 
        public void AssertWriting()
        {
            lock (this.synchObj)
            {
                if (!this.isWriting)
                    throw new InvalidOperationException("Not in a writing state.");
            }
        }
 
        public void AssertReadingOrWriting()
        {
            lock (this.synchObj)
            {
                if (this.nrReaders <= 0 && !this.isWriting)
                    throw new InvalidOperationException("Not in a reading or writing state.");
            }
        }
 
        public long Token
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.token;
                }
            }
        }
 
        public virtual async Task<int> BeginRead()
        {
            TaskCompletionSource<bool> Wait = null;
 
            while (true)
            {
                lock (this.synchObj)
                {
                    if (!this.isWriting)
                    {
                        if (this.nrReaders == 0)
                            this.token++;
 
                        return ++this.nrReaders;
                    }
                    else
                    {
                        Wait = new TaskCompletionSource<bool>();
                        this.noWriters.AddLast(Wait);
                    }
                }
 
                await Wait.Task;
            }
        }
 
        public virtual Task<int> EndRead()
        {
            LinkedList<TaskCompletionSource<bool>> List = null;
 
            lock (this.synchObj)
            {
                if (this.nrReaders <= 0)
                    throw new InvalidOperationException("Not in a reading state.");
 
                this.nrReaders--;
                if (this.nrReaders == 0)
                    this.token++;
                else
                    return Task.FromResult<int>(this.nrReaders);
 
                if (this.noReadersOrWriters.First is null)
                    return Task.FromResult<int>(0);
 
                List = this.noReadersOrWriters;
                this.noReadersOrWriters = new LinkedList<TaskCompletionSource<bool>>();
            }
 
            foreach (TaskCompletionSource<bool> T in List)
                T.TrySetResult(true);
 
            return Task.FromResult<int>(0);
        }
 
        public virtual async Task<bool> TryBeginRead(int Timeout)
        {
            TaskCompletionSource<bool> Wait = null;
            DateTime Start = DateTime.Now;
 
            while (true)
            {
                lock (this.synchObj)
                {
                    if (!this.isWriting)
                    {
                        if (this.nrReaders == 0)
                            this.token++;
 
                        this.nrReaders++;
                        return true;
                    }
                    else if (Timeout <= 0)
                        return false;
                    else
                    {
                        Wait = new TaskCompletionSource<bool>();
                        this.noWriters.AddLast(Wait);
                    }
                }
 
                using (Timer Timer = new Timer((P) =>
                {
                    Wait.TrySetResult(false);
 
                }, null, Timeout, System.Threading.Timeout.Infinite))
                {
                    DateTime Now = DateTime.Now;
                    bool Result = await Wait.Task;
                    if (!Result)
                    {
                        lock (this.synchObj)
                        {
                            this.noWriters.Remove(Wait);
                        }
 
                        return false;
                    }
 
                    Timeout -= (int)((Now - Start).TotalMilliseconds + 0.5);
                    Start = Now;
                }
            }
        }
 
        public virtual async Task BeginWrite()
        {
            TaskCompletionSource<bool> Prev = null;
            TaskCompletionSource<bool> Wait = null;
 
            while (true)
            {
                lock (this.synchObj)
                {
                    if (!(Prev is null))
                        this.noWriters.Remove(Prev);    // In case previously locked for reading
 
                    if (this.nrReaders == 0 && !this.isWriting)
                    {
                        this.token++;
                        this.isWriting = true;
                        return;
                    }
                    else
                    {
                        Wait = new TaskCompletionSource<bool>();
                        this.noReadersOrWriters.AddLast(Wait);
                        this.noWriters.AddLast(Wait);
                    }
                }
 
                await Wait.Task;
                Prev = Wait;
            }
        }
 
        public virtual Task EndWrite()
        {
            LinkedList<TaskCompletionSource<bool>> List = null;
            LinkedList<TaskCompletionSource<bool>> List2 = null;
 
            lock (this.synchObj)
            {
                if (!this.isWriting)
                    throw new InvalidOperationException("Not in a writing state.");
 
                this.token++;
                this.isWriting = false;
 
                if (!(this.noReadersOrWriters.First is null))
                {
                    List = this.noReadersOrWriters;
                    this.noReadersOrWriters = new LinkedList<TaskCompletionSource<bool>>();
                }
 
                if (!(this.noWriters.First is null))
                {
                    List2 = this.noWriters;
                    this.noWriters = new LinkedList<TaskCompletionSource<bool>>();
                }
            }
 
            if (!(List is null))
            {
                foreach (TaskCompletionSource<bool> T in List)
                    T.TrySetResult(true);
            }
 
            if (!(List2 is null))
            {
                foreach (TaskCompletionSource<bool> T in List2)
                    T.TrySetResult(true);
            }
 
            return Task.CompletedTask;
        }
 
        public virtual async Task<bool> TryBeginWrite(int Timeout)
        {
            TaskCompletionSource<bool> Prev = null;
            TaskCompletionSource<bool> Wait = null;
            DateTime Start = DateTime.Now;
 
            while (true)
            {
                lock (this.synchObj)
                {
                    if (!(Prev is null))
                        this.noWriters.Remove(Prev);    // In case previously locked for reading
 
                    if (this.nrReaders == 0 && !this.isWriting)
                    {
                        this.token++;
                        this.isWriting = true;
                        return true;
                    }
                    else if (Timeout <= 0)
                        return false;
                    else
                    {
                        Wait = new TaskCompletionSource<bool>();
                        this.noWriters.AddLast(Wait);
                        this.noReadersOrWriters.AddLast(Wait);
                    }
                }
 
                using (Timer Timer = new Timer((P) =>
                {
                    Wait.TrySetResult(false);
 
                }, null, Timeout, System.Threading.Timeout.Infinite))
                {
                    DateTime Now = DateTime.Now;
                    bool Result = await Wait.Task;
                    if (!Result)
                    {
                        lock (this.synchObj)
                        {
                            this.noWriters.Remove(Wait);
                            this.noReadersOrWriters.Remove(Wait);
                        }
 
                        return false;
                    }
 
                    Timeout -= (int)((Now - Start).TotalMilliseconds + 0.5);
                    Start = Now;
                    Prev = Wait;
                }
            }
        }
 
        public virtual Task Unlock()
        {
            LinkedList<TaskCompletionSource<bool>> List = null;
            LinkedList<TaskCompletionSource<bool>> List2 = null;
 
            lock (this.synchObj)
            {
                this.nrReaders = 0;
                this.isWriting = false;
                this.token++;
 
                if (!(this.noReadersOrWriters.First is null))
                {
                    List = this.noReadersOrWriters;
                    this.noReadersOrWriters = new LinkedList<TaskCompletionSource<bool>>();
                }
 
                if (!(this.noWriters.First is null))
                {
                    List2 = this.noWriters;
                    this.noWriters = new LinkedList<TaskCompletionSource<bool>>();
                }
            }
 
            if (!(List is null))
            {
                foreach (TaskCompletionSource<bool> T in List)
                    T.TrySetResult(false);
            }
 
            if (!(List2 is null))
            {
                foreach (TaskCompletionSource<bool> T in List2)
                    T.TrySetResult(false);
            }
 
            return Task.CompletedTask;
        }
 
        public virtual void Dispose()
        {
            this.Unlock();
        }
 
    }
}