C# System.Threading.ReaderWriterLockSlim

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C# System.Threading.ReaderWriterLockSlim，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10454字，纯文字阅读大概需要15分钟。

内容图文

  1 using System;
  2 using System.Threading;
  3 using System.Threading.Tasks;
  4 using System.Collections.Generic;
  5 
  6 public class SynchronizedCache 
  7 {
  8     private ReaderWriterLockSlim cacheLock = new ReaderWriterLockSlim();
  9     private Dictionary<int, string> innerCache = new Dictionary<int, string>();
 10 
 11     public int Count
 12     { get { return innerCache.Count; } }
 13 
 14     public string Read(int key)
 15     {
 16         cacheLock.EnterReadLock();
 17         try
 18         {
 19             return innerCache[key];
 20         }
 21         finally
 22         {
 23             cacheLock.ExitReadLock();
 24         }
 25     }
 26 
 27     public void Add(int key, string value)
 28     {
 29         cacheLock.EnterWriteLock();
 30         try
 31         {
 32             innerCache.Add(key, value);
 33         }
 34         finally
 35         {
 36             cacheLock.ExitWriteLock();
 37         }
 38     }
 39 
 40     public bool AddWithTimeout(int key, string value, int timeout)
 41     {
 42         if (cacheLock.TryEnterWriteLock(timeout))
 43         {
 44             try
 45             {
 46                 innerCache.Add(key, value);
 47             }
 48             finally
 49             {
 50                 cacheLock.ExitWriteLock();
 51             }
 52             return true;
 53         }
 54         else
 55         {
 56             return false;
 57         }
 58     }
 59 
 60     public AddOrUpdateStatus AddOrUpdate(int key, string value)
 61     {
 62         cacheLock.EnterUpgradeableReadLock();
 63         try
 64         {
 65             string result = null;
 66             if (innerCache.TryGetValue(key, out result))
 67             {
 68                 if (result == value)
 69                 {
 70                     return AddOrUpdateStatus.Unchanged;
 71                 }
 72                 else
 73                 {
 74                     cacheLock.EnterWriteLock();
 75                     try
 76                     {
 77                         innerCache[key] = value;
 78                     }
 79                     finally
 80                     {
 81                         cacheLock.ExitWriteLock();
 82                     }
 83                     return AddOrUpdateStatus.Updated;
 84                 }
 85             }
 86             else
 87             {
 88                 cacheLock.EnterWriteLock();
 89                 try
 90                 {
 91                     innerCache.Add(key, value);
 92                 }
 93                 finally
 94                 {
 95                     cacheLock.ExitWriteLock();
 96                 }
 97                 return AddOrUpdateStatus.Added;
 98             }
 99         }
100         finally
101         {
102             cacheLock.ExitUpgradeableReadLock();
103         }
104     }
105 
106     public void Delete(int key)
107     {
108         cacheLock.EnterWriteLock();
109         try
110         {
111             innerCache.Remove(key);
112         }
113         finally
114         {
115             cacheLock.ExitWriteLock();
116         }
117     }
118 
119     public enum AddOrUpdateStatus
120     {
121         Added,
122         Updated,
123         Unchanged
124     };
125 
126     ~SynchronizedCache()
127     {
128        if (cacheLock != null) cacheLock.Dispose();
129     }
130 }

  1 using System;
  2 using System.Threading;
  3 using System.Threading.Tasks;
  4 using System.Collections.Generic;
  5 
  6 public class Example
  7 {
  8    public static void Main()
  9    {
 10       var sc = new SynchronizedCache();
 11       var tasks = new List<Task>();
 12       int itemsWritten = 0;
 13 
 14       // Execute a writer.
 15       tasks.Add(Task.Run( () => { String[] vegetables = { "broccoli", "cauliflower",
 16                                                           "carrot", "sorrel", "baby turnip",
 17                                                           "beet", "brussel sprout",
 18                                                           "cabbage", "plantain",
 19                                                           "spinach", "grape leaves",
 20                                                           "lime leaves", "corn",
 21                                                           "radish", "cucumber",
 22                                                           "raddichio", "lima beans" };
 23                                   for (int ctr = 1; ctr <= vegetables.Length; ctr++)
 24                                      sc.Add(ctr, vegetables[ctr - 1]);
 25 
 26                                   itemsWritten = vegetables.Length;
 27                                   Console.WriteLine("Task {0} wrote {1} items\n",
 28                                                     Task.CurrentId, itemsWritten);
 29                                 } ));
 30       // Execute two readers, one to read from first to last and the second from last to first.
 31       for (int ctr = 0; ctr <= 1; ctr++) {
 32          bool desc = Convert.ToBoolean(ctr);
 33          tasks.Add(Task.Run( () => { int start, last, step;
 34                                      int items;
 35                                      do {
 36                                         String output = String.Empty;
 37                                         items = sc.Count;
 38                                         if (! desc) {
 39                                            start = 1;
 40                                            step = 1;
 41                                            last = items;
 42                                         }
 43                                         else {
 44                                            start = items;
 45                                            step = -1;
 46                                            last = 1;
 47                                         }
 48 
 49                                         for (int index = start; desc ? index >= last : index <= last; index += step)
 50                                            output += String.Format("[{0}] ", sc.Read(index));
 51 
 52                                         Console.WriteLine("Task {0} read {1} items: {2}\n",
 53                                                           Task.CurrentId, items, output);
 54                                      } while (items < itemsWritten | itemsWritten == 0);
 55                              } ));
 56       }
 57       // Execute a red/update task.
 58       tasks.Add(Task.Run( () => { Thread.Sleep(100);
 59                                   for (int ctr = 1; ctr <= sc.Count; ctr++) {
 60                                      String value = sc.Read(ctr);
 61                                      if (value == "cucumber")
 62                                         if (sc.AddOrUpdate(ctr, "green bean") != SynchronizedCache.AddOrUpdateStatus.Unchanged)
 63                                            Console.WriteLine("Changed 'cucumber' to 'green bean'");
 64                                   }
 65                                 } ));
 66 
 67       // Wait for all three tasks to complete.
 68       Task.WaitAll(tasks.ToArray());
 69 
 70       // Display the final contents of the cache.
 71       Console.WriteLine();
 72       Console.WriteLine("Values in synchronized cache: ");
 73       for (int ctr = 1; ctr <= sc.Count; ctr++)
 74          Console.WriteLine("   {0}: {1}", ctr, sc.Read(ctr));
 75 
 76    }
 77 }
 78 // The example displays the following output:
 79 //    Task 1 read 0 items:
 80 //
 81 //    Task 3 wrote 17 items
 82 //
 83 //
 84 //    Task 1 read 17 items: [broccoli] [cauliflower] [carrot] [sorrel] [baby turnip] [
 85 //    beet] [brussel sprout] [cabbage] [plantain] [spinach] [grape leaves] [lime leave
 86 //    s] [corn] [radish] [cucumber] [raddichio] [lima beans]
 87 //
 88 //    Task 2 read 0 items:
 89 //
 90 //    Task 2 read 17 items: [lima beans] [raddichio] [cucumber] [radish] [corn] [lime
 91 //    leaves] [grape leaves] [spinach] [plantain] [cabbage] [brussel sprout] [beet] [b
 92 //    aby turnip] [sorrel] [carrot] [cauliflower] [broccoli]
 93 //
 94 //    Changed 'cucumber' to 'green bean'
 95 //
 96 //    Values in synchronized cache:
 97 //       1: broccoli
 98 //       2: cauliflower
 99 //       3: carrot
100 //       4: sorrel
101 //       5: baby turnip
102 //       6: beet
103 //       7: brussel sprout
104 //       8: cabbage
105 //       9: plantain
106 //       10: spinach
107 //       11: grape leaves
108 //       12: lime leaves
109 //       13: corn
110 //       14: radish
111 //       15: green bean
112 //       16: raddichio
113 //       17: lima beans

构造函数 

属性 

方法 

内容总结

以上是互联网集市为您收集整理的C# System.Threading.ReaderWriterLockSlim全部内容，希望文章能够帮你解决C# System.Threading.ReaderWriterLockSlim所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端