ReaderWriterLock类

ReaderWriterLock类定义了实现单写程序和多读程序语义的锁。这个类主要用于文件操作，即多个线程可以读取文件，但只能用一个线程来更新文件。
使用ReaderWriterLock类时，任意数量的线程都可以同时安全地读取数据。只有当线程进行更新时，数据才被锁定。只有在没有占用锁的写程序线程时，读程序线程才能获得锁。只有在没有占用锁的读程序或者写程序线程时，写程序线程才能获得锁。
ReaderWriterLock中4个主要的方法是：
   1.AcquireReaderLock():该重载方法获得一个读程序锁，超时值使用整数或者TimeSpan。
   2.AcaureWriterLock():该重载方法获得一个写程序锁，超时值使用整数或者TimeSpane。
   3.ReleaseReaderLock():释放读程序锁。
   4.ReleaseWriterLock():释放写程序锁。

using System;
using System.Threading;
using System.Runtime.CompilerServices;



public class ClassForMain
...{
    public class ReadWrite
    ...{
        private ReaderWriterLock rwl;
        private int x;
        private int y;

        public ReadWrite()
        ...{
            rwl = new ReaderWriterLock();
        }

        public void ReadInts(ref int a, ref int b)
        ...{
            rwl.AcquireReaderLock(Timeout.Infinite);
            try
            ...{
                a = this.x;
                b = this.y;
            }
            finally
            ...{
                rwl.ReleaseReaderLock();
            }

        }

        public void WriteInts(int a, int b)
        ...{

            rwl.AcquireWriterLock(Timeout.Infinite);

            this.x = a;
            this.y = b;
            try
            ...{
                Console.WriteLine("Begin write...");

                Console.WriteLine("x=" + this.x + "y=" + this.y + "ThreadID=" +
                    Thread.CurrentThread.GetHashCode());
            }
            finally
            ...{
                rwl.ReleaseWriterLock();
                Console.WriteLine("End write!");
            }
        }

        public class RWApp
        ...{
            private ReadWrite rw = new ReadWrite();
            public static void Main(string[] args)
            ...{
                RWApp e = new RWApp();

                //Write Threads
                Thread wl1 = new Thread(new ThreadStart(e.Write));
                wl1.Start();
                Thread wl2 = new Thread(new ThreadStart(e.Write));
                wl2.Start();
               
                //Reader Threads
                Thread rt1 = new Thread(new ThreadStart(e.Read));
                rt1.Start();
                Thread rt2 = new Thread(new ThreadStart(e.Read));
                rt2.Start();
                 Thread rt3 = new Thread(new ThreadStart(e.Read));
                rt3.Start();
            }

            private void Write()
            ...{
                int a = 10; 
                int b = 11;
             

                for (int i = 0; i < 5; i++)
                ...{
                    this.rw.WriteInts(a++, b++);
                    Thread.Sleep(1000);
                }
            }
            private void Read()
            ...{
                int a = 10;
                int b = 11;
            
             
                for (int i = 0; i < 5; i++)
                ...{
                   
                    this.rw.ReadInts(ref a, ref b); 
                    Console.WriteLine("For i=" + i + "||a=" + a + "||b=" + b +
                        "ThreadID=" + Thread.CurrentThread.GetHashCode());
                   
                    Thread.Sleep(1000);
                }
              
            }
        }
    }
}
     

在上例中，线程wt1和wt2是在WriteInts()方法中获取写程序锁的写程序线程，线程rt1和rt2是在ReadInts()方法中获取读程序锁的读程序线程。在WriteInts()方法中，实例变量x和y分别变为新值a和b。当线程wt1或wt2通过调用AcqireWriteLock()获取写程序锁时，其他线程(包括读程序线程rt1和rt2)就不能访问对象，直到线程wt1和wt2通过调用ReleaseWriterLock()释放了写程序锁。在ReadInts()方法中，线程rt1和rt2通过ReleaseWriterLock()释放了写程序锁。在ReadInts()方法中，线程rt1和rt2通过调用　AcquireReadLock()方法获得读程序锁。在ReadInts()方法中，线程rt1和rt2可以同时访问实例变量x和y。写程序线程(wt1和wt2)都无法访问对象，直到读程序释放读程序锁。在获取读程序锁后，读程序线程才能同时访问对象。

ReaderWriterLock类允许任意多的线程同时读取数据，提供　了一种处理数据读写访问的最佳方案。仅当线程更新数据时，它才锁定数据。当且仅当没有写程序线程占用锁时，坊程序线程才能获得锁。当且仅当没有读程序或写程序线程占用锁时，写程序线程才能获得锁。