zoukankan      html  css  js  c++  java
  • 如何使用C#读写锁ReaderWriterLockSlim

    参考网址: https://www.jb51.net/article/69869.htm

    读写锁的概念很简单,允许多个线程同时获取读锁,但同一时间只允许一个线程获得写锁,因此也称作共享-独占锁。在C#中,推荐使用ReaderWriterLockSlim类来完成读写锁的功能。
    某些场合下,对一个对象的读取次数远远大于修改次数,如果只是简单的用lock方式加锁,则会影响读取的效率。而如果采用读写锁,则多个线程可以同时读取该对象,只有等到对象被写入锁占用的时候,才会阻塞。
    简单的说,当某个线程进入读取模式时,此时其他线程依然能进入读取模式,假设此时一个线程要进入写入模式,那么他不得不被阻塞。直到读取模式退出为止。
    同样的,如果某个线程进入了写入模式,那么其他线程无论是要写入还是读取,都是会被阻塞的。
    进入写入/读取模式有2种方法:
    EnterReadLock尝试进入写入模式锁定状态。
    TryEnterReadLock(Int32) 尝试进入读取模式锁定状态,可以选择整数超时时间。
    EnterWriteLock 尝试进入写入模式锁定状态。
    TryEnterWriteLock(Int32) 尝试进入写入模式锁定状态,可以选择超时时间。
    退出写入/读取模式有2种方法:
    ExitReadLock 减少读取模式的递归计数,并在生成的计数为 0(零)时退出读取模式。
    ExitWriteLock 减少写入模式的递归计数,并在生成的计数为 0(零)时退出写入模式。
    下面演示一下用法:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    public class Program
      {
        static private ReaderWriterLockSlim rwl = new ReaderWriterLockSlim();
        static void Main(string[] args)
        {
          Thread t_read1 = new Thread(new ThreadStart(ReadSomething));
          t_read1.Start();
          Console.WriteLine("{0} Create Thread ID {1} , Start ReadSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_read1.GetHashCode());
          Thread t_read2 = new Thread(new ThreadStart(ReadSomething));
          t_read2.Start();
          Console.WriteLine("{0} Create Thread ID {1} , Start ReadSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_read2.GetHashCode());
          Thread t_write1 = new Thread(new ThreadStart(WriteSomething));
          t_write1.Start();
          Console.WriteLine("{0} Create Thread ID {1} , Start WriteSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_write1.GetHashCode());
        }
        static public void ReadSomething()
        {
          Console.WriteLine("{0} Thread ID {1} Begin EnterReadLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          rwl.EnterReadLock();
          try
          {
            Console.WriteLine("{0} Thread ID {1} reading sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
            Thread.Sleep(5000);//模拟读取信息
            Console.WriteLine("{0} Thread ID {1} reading end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          }
          finally
          {
            rwl.ExitReadLock();
            Console.WriteLine("{0} Thread ID {1} ExitReadLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          }
        }
        static public void WriteSomething()
        {
          Console.WriteLine("{0} Thread ID {1} Begin EnterWriteLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          rwl.EnterWriteLock();
          try
          {
            Console.WriteLine("{0} Thread ID {1} writing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
            Thread.Sleep(10000);//模拟写入信息
            Console.WriteLine("{0} Thread ID {1} writing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          }
          finally
          {
            rwl.ExitWriteLock();
            Console.WriteLine("{0} Thread ID {1} ExitWriteLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          }
        }
      }

    可以看到3号线程和4号线程能够同时进入读模式,而5号线程过了5秒钟后(即3,4号线程退出读锁后),才能进入写模式。
    把上述代码修改一下,先开启2个写模式的线程,然后在开启读模式线程,代码如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    static void Main(string[] args)
       {
         Thread t_write1 = new Thread(new ThreadStart(WriteSomething));
         t_write1.Start();
         Console.WriteLine("{0} Create Thread ID {1} , Start WriteSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_write1.GetHashCode());
         Thread t_write2 = new Thread(new ThreadStart(WriteSomething));
         t_write2.Start();
         Console.WriteLine("{0} Create Thread ID {1} , Start WriteSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_write2.GetHashCode());
         Thread t_read1 = new Thread(new ThreadStart(ReadSomething));
         t_read1.Start();
         Console.WriteLine("{0} Create Thread ID {1} , Start ReadSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_read1.GetHashCode());
         Thread t_read2 = new Thread(new ThreadStart(ReadSomething));
         t_read2.Start();
         Console.WriteLine("{0} Create Thread ID {1} , Start ReadSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_read2.GetHashCode());
       }

    结果如下:

    可以看到,3号线程和4号线程都要进入写模式,但是3号线程先占用写入锁,因此4号线程不得不等了10s后才进入。5号线程和6号线程需要占用读取锁,因此等4号线程退出写入锁后才能继续下去。
    TryEnterReadLock和TryEnterWriteLock可以设置一个超时时间,运行到这句话的时候,线程会阻塞在此,如果此时能占用锁,那么返回true,如果到超时时间还未占用锁,那么返回false,放弃锁的占用,直接继续执行下面的代码。
    EnterUpgradeableReadLock
    ReaderWriterLockSlim类提供了可升级读模式,这种方式和读模式的区别在于它还有通过调用 EnterWriteLock 或 TryEnterWriteLock 方法升级为写入模式。 因为每次只能有一个线程处于可升级模式。进入可升级模式的线程,不会影响读取模式的线程,即当一个线程进入可升级模式,任意数量线程可以同时进入读取模式,不会阻塞。如果有多个线程已经在等待获取写入锁,那么运行EnterUpgradeableReadLock将会阻塞,直到那些线程超时或者退出写入锁。
    下面代码演示了如何在可升级读模式下,升级到写入锁。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    static public void UpgradeableRead()
        {
          Console.WriteLine("{0} Thread ID {1} Begin EnterUpgradeableReadLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          rwl.EnterUpgradeableReadLock();
          try
          {
            Console.WriteLine("{0} Thread ID {1} doing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
            Console.WriteLine("{0} Thread ID {1} Begin EnterWriteLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
            rwl.EnterWriteLock();
            try
            {
              Console.WriteLine("{0} Thread ID {1} writing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
              Thread.Sleep(10000);//模拟写入信息
              Console.WriteLine("{0} Thread ID {1} writing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
            }
            finally
            {
              rwl.ExitWriteLock();
              Console.WriteLine("{0} Thread ID {1} ExitWriteLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
            }
            Thread.Sleep(10000);//模拟读取信息
            Console.WriteLine("{0} Thread ID {1} doing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          }
          finally
          {
            rwl.ExitUpgradeableReadLock();
            Console.WriteLine("{0} Thread ID {1} ExitUpgradeableReadLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          }
        }

    读写锁对于性能的影响是明显的。
    下面测试代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    public class Program
      {
        static private ReaderWriterLockSlim rwl = new ReaderWriterLockSlim();
        static void Main(string[] args)
        {
          Stopwatch sw = new Stopwatch();
          sw.Start();
          List<Task> lstTask = new List<Task>();
          for (int i = 0; i < 500; i++)
          {
            if (i % 25 != 0)
            {
              var t = Task.Factory.StartNew(ReadSomething);
              lstTask.Add(t);
            }
            else
            {
              var t = Task.Factory.StartNew(WriteSomething);
              lstTask.Add(t);
            }
          }
          Task.WaitAll(lstTask.ToArray());
          sw.Stop();
          Console.WriteLine("使用ReaderWriterLockSlim方式,耗时:" + sw.Elapsed);
          sw.Restart();
          lstTask = new List<Task>();
          for (int i = 0; i < 500; i++)
          {
            if (i % 25 != 0)
            {
              var t = Task.Factory.StartNew(ReadSomething_lock);
              lstTask.Add(t);
            }
            else
            {
              var t = Task.Factory.StartNew(WriteSomething_lock);
              lstTask.Add(t);
            }
          }
          Task.WaitAll(lstTask.ToArray());
          sw.Stop();
          Console.WriteLine("使用lock方式,耗时:" + sw.Elapsed);
        }
        static private object _lock1 = new object();
        static public void ReadSomething_lock()
        {
          lock (_lock1)
          {
            //Console.WriteLine("{0} Thread ID {1} reading sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
            Thread.Sleep(10);//模拟读取信息
            //Console.WriteLine("{0} Thread ID {1} reading end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          }
        }
        static public void WriteSomething_lock()
        {
          lock (_lock1)
          {
            //Console.WriteLine("{0} Thread ID {1} writing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
            Thread.Sleep(100);//模拟写入信息
            //Console.WriteLine("{0} Thread ID {1} writing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          }
        }
        static public void ReadSomething()
        {
          rwl.EnterReadLock();
          try
          {
            //Console.WriteLine("{0} Thread ID {1} reading sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
            Thread.Sleep(10);//模拟读取信息
            //Console.WriteLine("{0} Thread ID {1} reading end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          }
          finally
          {
            rwl.ExitReadLock();
          }
        }
        static public void WriteSomething()
        {
          rwl.EnterWriteLock();
          try
          {
            //Console.WriteLine("{0} Thread ID {1} writing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
            Thread.Sleep(100);//模拟写入信息
            //Console.WriteLine("{0} Thread ID {1} writing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
          }
          finally
          {
            rwl.ExitWriteLock();
          }
        }
      }

    上述代码,就500个Task,每个Task占用一个线程池线程,其中20个写入线程和480个读取线程,模拟操作。其中读取数据花10ms,写入操作花100ms,分别测试了对于lock方式和ReaderWriterLockSlim方式。可以做一个估算,对于ReaderWriterLockSlim,假设480个线程同时读取,那么消耗10ms,20个写入操作占用2000ms,因此所消耗时间2010ms,而对于普通的lock方式,由于都是独占性的,因此480个读取操作占时间4800ms+20个写入操作2000ms=6800ms。运行结果显示了性能提升明显。

    以上是本文的全部内容,希望对大家熟练应用读写锁ReaderWriterLockSlim有所帮助。

  • 相关阅读:
    Codeforces 1316B String Modification
    Codeforces 1305C Kuroni and Impossible Calculation
    Codeforces 1305B Kuroni and Simple Strings
    Codeforces 1321D Navigation System
    Codeforces 1321C Remove Adjacent
    Codeforces 1321B Journey Planning
    Operating systems Chapter 6
    Operating systems Chapter 5
    Abandoned country HDU
    Computer HDU
  • 原文地址:https://www.cnblogs.com/bruce1992/p/15318912.html
Copyright © 2011-2022 走看看