c#-Silverlight ReaderWriterLock实现好/不好？

我有一个适用于Silverlight的简单(无升级或超时)ReaderWriterLock的adopted实现,我想知道任何具有适当专业知识的人都可以通过设计验证它的好坏.对我来说,它看起来还不错,可以像宣传的那样工作,但是我对使用多线程代码的经验有限.

public sealed class ReaderWriterLock
{
    private readonly object syncRoot = new object();    // Internal lock.
    private int i = 0;                                  // 0 or greater means readers can pass; -1 is active writer.
    private int readWaiters = 0;                        // Readers waiting for writer to exit.
    private int writeWaiters = 0;                       // Writers waiting for writer lock.
    private ConditionVariable conditionVar;             // Condition variable.

    public ReaderWriterLock()
    {
        conditionVar = new ConditionVariable(syncRoot);
    }

    /// <summary>
    /// Gets a value indicating if a reader lock is held.
    /// </summary>
    public bool IsReaderLockHeld
    {
        get
        {
            lock ( syncRoot )
            {
                if ( i > 0 )
                    return true;
                return false;
            }
        }
    }

    /// <summary>
    /// Gets a value indicating if the writer lock is held.
    /// </summary>
    public bool IsWriterLockHeld
    {
        get
        {
            lock ( syncRoot )
            {
                if ( i < 0 )
                    return true;
                return false;
            }
        }
    }

    /// <summary>
    /// Aquires the writer lock.
    /// </summary>
    public void AcquireWriterLock()
    {
        lock ( syncRoot )
        {
            writeWaiters++;
            while ( i != 0 )
                conditionVar.Wait();      // Wait until existing writer frees the lock.
            writeWaiters--;
            i = -1;             // Thread has writer lock.
        }
    }

    /// <summary>
    /// Aquires a reader lock.
    /// </summary>
    public void AcquireReaderLock()
    {
        lock ( syncRoot )
        {
            readWaiters++;
            // Defer to a writer (one time only) if one is waiting to prevent writer starvation.
            if ( writeWaiters > 0 )
            {
                conditionVar.pulse();
                Monitor.Wait(syncRoot);
            }
            while ( i < 0 )
                Monitor.Wait(syncRoot);
            readWaiters--;
            i++;
        }
    }

    /// <summary>
    /// Releases the writer lock.
    /// </summary>
    public void ReleaseWriterLock()
    {
        bool dopulse = false;
        lock ( syncRoot )
        {
            i = 0;
            // Decide if we pulse a writer or readers.
            if ( readWaiters > 0 )
            {
                Monitor.pulseAll(syncRoot); // If multiple readers waiting, pulse them all.
            }
            else
            {
                dopulse = true;
            }
        }
        if ( dopulse )
            conditionVar.pulse();                     // pulse one writer if one waiting.
    }

    /// <summary>
    /// Releases a reader lock.
    /// </summary>
    public void ReleaseReaderLock()
    {
        bool dopulse = false;
        lock ( syncRoot )
        {
            i--;
            if ( i == 0 )
                dopulse = true;
        }
        if ( dopulse )
            conditionVar.pulse();                     // pulse one writer if one waiting.
    }

    /// <summary>
    /// Condition Variable (CV) class.
    /// </summary>
    public class ConditionVariable
    {
        private readonly object syncLock = new object(); // Internal lock.
        private readonly object m;                       // The lock associated with this CV.

        public ConditionVariable(object m)
        {
            lock (syncLock)
            {
                this.m = m;
            }
        }

        public void Wait()
        {
            bool enter = false;
            try
            {
                lock (syncLock)
                {
                    Monitor.Exit(m);
                    enter = true;
                    Monitor.Wait(syncLock);
                }
            }
            finally
            {
                if (enter)
                    Monitor.Enter(m);
            }
        }

        public void pulse()
        {
            lock (syncLock)
            {
                Monitor.pulse(syncLock);
            }
        }

        public void pulseAll()
        {
            lock (syncLock)
            {
                Monitor.pulseAll(syncLock);
            }
        }

    }

} 

如果效果很好,那么由于Silverlight当前缺少读写器类型的锁,这可能也会对其他人有所帮助.谢谢.

解决方法:

我将深入解释Vance Morrison’s ReaderWriterLock(在.NET 3.5中成为readerwriterlockslim)on my blog(降至x86级别).这可能对您的设计有所帮助,尤其是了解事情的实际运行方式.