多线程下解决资源竞争的7种方法

前言

  一般情况下,只要涉及到多线程编程,程序的复杂性就会显著上升,性能显著下降,BUG出现的概率大大提升。

多线程编程本意是将一段程序并行运行,提升数据处理能力,但是由于大部分情况下都涉及到共有资源的竞争,所以修改资源

对象时必须加锁处理。但是锁的实现有很多种方法,下面就来一起了解一下在C#语言中几种锁的实现与其性能表现。

 

一、c#下的几种锁的运用方式

1、临界区,通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访

          private static object obj = new object();
          private static int lockInt;
          private static void LockIntAdd()
          {
              for (var i = 0; i < runTimes; i++)
              {
                  lock (obj)
                  {
                      lockInt++;
                 }
             }
         }

 

你没看错,c#中的lock语法就是临界区(Monitor)的一个语法糖,这大概是90%以上的.net程序员首先想到的锁,不过大部分人都只是知道

有这么个语法,不知道其实是以临界区的方式处理资源竞争。

 

2、互斥量,为协调共同对一个共享资源的单独访问而设计的。

c#中有一个Mutex类,就在System.Threading命名空间下,Mutex其实就是互斥量,互斥量不单单能处理多线程之间的资源竞争,还能处理

进程之间的资源竞争,功能是比较强大的,但是开销也很大,性能比较低。

 

          private static Mutex mutex = new Mutex();
          private static int mutexInt;
          private static void MutexIntAdd()
          {
              for (var i = 0; i < runTimes; i++)
              {
                  mutex.WaitOne();
                  mutexInt++;
                  mutex.ReleaseMutex();
             }
         }

 

 

3、信号量,为控制一个具有有限数量用户资源而设计。

 1         private static Semaphore sema = new Semaphore(1, 1);
 2         private static int semaphoreInt;
 3         private static void SemaphoreIntAdd()
 4         {
 5             for (var i = 0; i < runTimes; i++)
 6             {
 7                 sema.WaitOne();
 8                 semaphoreInt++;
 9                 sema.Release();
10             }
11         }

 

 

4、事   件:用来通知线程有一些事件已发生,从而启动后继任务的开始。

 1         public static AutoResetEvent autoResetEvent = new AutoResetEvent(true);
 2         private static int autoResetEventInt;
 3         private static void AutoResetEventIntAdd()
 4         {
 5             for (var i = 0; i < runTimes; i++)
 6             {
 7                 if (autoResetEvent.WaitOne())
 8                 {
 9                     autoResetEventInt++;
10                     autoResetEvent.Set();
11                 }
12             }
13         }

 

 

5、读写锁,这种锁允许在有其他程序正在写的情况下读取资源,所以如果资源允许脏读,用这个比较合适

 1         private static ReaderWriterLockSlim LockSlim = new ReaderWriterLockSlim();
 2         private static int lockSlimInt;
 3         private static void LockSlimIntAdd()
 4         {
 5             for (var i = 0; i < runTimes; i++)
 6             {
 7                 LockSlim.EnterWriteLock();
 8                 lockSlimInt++;
 9                 LockSlim.ExitWriteLock();
10             }
11         }

 

 

6、原子锁,通过原子操作Interlocked.CompareExchange实现“无锁”竞争

 1         private static int isLock;
 2         private static int ceInt;
 3         private static void CEIntAdd()
 4         {
 5             //long tmp = 0;
 6             for (var i = 0; i < runTimes; i++)
 7             {
 8                 while (Interlocked.CompareExchange(ref isLock, 1, 0) == 1) { Thread.Sleep(1); }
 9 
10                 ceInt++;
11                 Interlocked.Exchange(ref isLock, 0);
12             }
13         }

 

 

7、原子性操作,这是一种特例,野外原子性操作本身天生线程安全,所以无需加锁

1         private static int atomicInt;
2         private static void AtomicIntAdd()
3         {
4             for (var i = 0; i < runTimes; i++)
5             {
6                 Interlocked.Increment(ref atomicInt);
7             }
8         }

 

 

8、不加锁,如果不加锁,那多线程下运行结果肯定是错的,这里贴上来比较一下性能

1         private static int noLockInt;
2         private static void NoLockIntAdd()
3         {
4             for (var i = 0; i < runTimes; i++)
5             {
6                 noLockInt++;
7             }
8         }

 

二、性能测试

1、测试代码,执行1000,10000,100000,1000000次

          private static void Run()
          {
              var stopwatch = new Stopwatch();
              var taskList = new Task[loopTimes];
  
              // 多线程
              Console.WriteLine();
              Console.WriteLine($"              线程数:{loopTimes}");
              Console.WriteLine($"            执行次数:{runTimes}");
             Console.WriteLine($"        校验值应等于:{runTimes * loopTimes}");
 
             // AtomicIntAdd
             stopwatch.Restart();
             for (var i = 0; i < loopTimes; i++)
             {
                 taskList[i] = Task.Factory.StartNew(() => { AtomicIntAdd(); });
             }
             Task.WaitAll(taskList);
             Console.WriteLine($"{GetFormat("AtomicIntAdd")}, 总耗时:{stopwatch.ElapsedMilliseconds}毫秒, 校验值:{atomicInt}");
 
             // CEIntAdd
             taskList = new Task[loopTimes];
             stopwatch.Restart();
 
             for (var i = 0; i < loopTimes; i++)
             {
                 taskList[i] = Task.Factory.StartNew(() => { CEIntAdd(); });
             }
             Task.WaitAll(taskList);
             Console.WriteLine($"{GetFormat("CEIntAdd")}, 总耗时:{stopwatch.ElapsedMilliseconds}毫秒, 校验值:{ceInt}");
 
             // LockIntAdd
             taskList = new Task[loopTimes];
             stopwatch.Restart();
 
             for (var i = 0; i < loopTimes; i++)
             {
                 taskList[i] = Task.Factory.StartNew(() => { LockIntAdd(); });
             }
             Task.WaitAll(taskList);
             Console.WriteLine($"{GetFormat("LockIntAdd")}, 总耗时:{stopwatch.ElapsedMilliseconds}毫秒, 校验值:{lockInt}");
 
             // MutexIntAdd
             taskList = new Task[loopTimes];
             stopwatch.Restart();
 
             for (var i = 0; i < loopTimes; i++)
             {
                 taskList[i] = Task.Factory.StartNew(() => { MutexIntAdd(); });
             }
             Task.WaitAll(taskList);
             Console.WriteLine($"{GetFormat("MutexIntAdd")}, 总耗时:{stopwatch.ElapsedMilliseconds}毫秒, 校验值:{mutexInt}");
 
             // LockSlimIntAdd
             taskList = new Task[loopTimes];
             stopwatch.Restart();
 
             for (var i = 0; i < loopTimes; i++)
             {
                 taskList[i] = Task.Factory.StartNew(() => { LockSlimIntAdd(); });
             }
             Task.WaitAll(taskList);
             Console.WriteLine($"{GetFormat("LockSlimIntAdd")}, 总耗时:{stopwatch.ElapsedMilliseconds}毫秒, 校验值:{lockSlimInt}");
 
             // SemaphoreIntAdd
             taskList = new Task[loopTimes];
             stopwatch.Restart();
 
             for (var i = 0; i < loopTimes; i++)
             {
                 taskList[i] = Task.Factory.StartNew(() => { SemaphoreIntAdd(); });
             }
             Task.WaitAll(taskList);
             Console.WriteLine($"{GetFormat("SemaphoreIntAdd")}, 总耗时:{stopwatch.ElapsedMilliseconds}毫秒, 校验值:{semaphoreInt}");
 
 
             // AutoResetEventIntAdd
             taskList = new Task[loopTimes];
             stopwatch.Restart();

             for (var i = 0; i < loopTimes; i++)
             {
                 taskList[i] = Task.Factory.StartNew(() => { AutoResetEventIntAdd(); });
             }
             Task.WaitAll(taskList);
             Console.WriteLine($"{GetFormat("AutoResetEventIntAdd")}, 总耗时:{stopwatch.ElapsedMilliseconds}毫秒, 校验值:{autoResetEventInt}");
 
             // NoLockIntAdd
             taskList = new Task[loopTimes];
             stopwatch.Restart();
 
             for (var i = 0; i < loopTimes; i++)
             {
                 taskList[i] = Task.Factory.StartNew(() => { NoLockIntAdd(); });
             }
             Task.WaitAll(taskList);
             Console.WriteLine($"{GetFormat("NoLockIntAdd")}, 总耗时:{stopwatch.ElapsedMilliseconds}毫秒, 校验值:{noLockInt}");
             Console.WriteLine();
         }

2、线程:10

3、线程:50

三、总结

 

1)在各种测试中,不加锁肯定是最快的,所以尽量避免资源竞争导致加锁运行

2)在多线程中Interlocked.CompareExchange始终表现出优越的性能,排在第二位

3)第三位lock,临界区也表现出很好的性能,所以在别人说lock性能低的时候请反驳他

4)第四位是原子性变量(Atomic)操作,不过目前只支持变量的自增自减,适用性不强

5)第五位读写锁(ReaderWriterLockSlim)表现也还可以,并且支持无所读,实用性还是比较好的

6)剩下的信号量、事件、互斥量,这三种性能最差,当然他们有各自的适用范围,只是在处理资源竞争这方面表现不好

1.几同步方法的区别 lock和Monitor是.NET用一个特殊结构实现的,Monitor对象是完全托管的、完全可移植的,并且在操作系统资源要求方 面可能更为有效,同步速度较快,但不能跨进程同步。lock(Monitor.Enter和Monitor.Exit方法的封装),主要作用是锁定临界区,使临 界区代码只能被获得锁的线程执行。Monitor.Wait和Monitor.Pulse用于线程同步,类似信号操作,个人感觉使用比较复杂,容易造成死 锁。 互斥体Mutex和事件对象EventWaitHandler属于内核对象,利用内核对象进行线程同步,线程必须要在用户模式和内核模 式间切换,所以一般效率很低,但利用互斥对象和事件对象这样的内核对象,可以在多个进程中的各个线程间进行同步。 互斥体Mutex类似于一个接力棒,拿到接力棒的线程才可以开始跑,当然接力棒一次只属于一个线程(Thread Affinity),如果这个线程不释放接力棒(Mutex.ReleaseMutex),那么没办法,其他所有需要接力棒运行的线程都知道能等着看热 闹。 EventWaitHandle 类允许线程通过发信号互相通信。 通常,一个或多个线程在 EventWaitHandle 上阻止,直到一个未阻止的线程调用 Set 方法,以释放一个或多个被阻止的线程。 2.什么时候需要锁定 首先要理解锁定是解决竞争条件的,也就是多个线程同时访问某个资源,造成意想不到的结果。比如,最简单的情况是,一个计数器,两个线程 同时加一,后果就是损失了一个计数,但相当频繁的锁定又可能带来性能上的消耗,还有最可怕的情况死锁。那么什么情况下我们需要使用锁,什么情况下不需要 呢? 1)只有共享资源才需要锁定 只有可以被多线程访问的共享资源才需要考虑锁定,比如静态变量,再比如某些缓存中的值,而属于线程内部的变量不需要锁定。 2)多使用lock,少用Mutex 如果你一定要使用锁定,请尽量不要使用内核模块的锁定机制,比如.NET的Mutex,Semaphore,AutoResetEvent和 ManuResetEvent,使用这样的机制涉及到了系统在用户模式和内核模式间的切换,性能差很多,但是他们的优点是可以跨进程同步线程,所以应该清 楚的了解到他们的不同和适用范围。 3)了解你的程序是怎么运行的 实际上在web开发中大多数逻辑都是在单个线程中展开的,一个请求都会在一个单独的线程中处理,其中的大部分变量都是属于这个线程的,根本没有必要考虑锁 定,当然对于ASP.NET中的Application对象中的数据,我们就要考虑加锁了。 4)把锁定交给数据库 数 据库除了存储数据之外,还有一个重要的用途就是同步,数据库本身用了一套复杂的机制来保证数据的可靠和一致性,这就为我们节省了很多的精力。保证了数据源 头上的同步,我们多数的精力就可以集中在缓存等其他一些资源的同步访问上了。通常,只有涉及到多个线程修改数据库中同一条记录时,我们才考虑加锁。 5)业务逻辑对事务和线程安全的要求 这 条是最根本的东西,开发完全线程安全的程序是件很费时费力的事情,在电子商务等涉及金融系统的案例中,许多逻辑都必须严格的线程安全,所以我们不得不牺牲 一些性能,和很多的开发时间来做这方面的工作。而一般的应用中,许多情况下虽然程序有竞争的危险,我们还是可以不使用锁定,比如有的时候计数器少一多一, 对结果无伤大雅的情况下,我们就可以不用去管它。 3.InterLocked类 Interlocked 类提供了同步对多个线程共享的变量的访问的方法。如果该变量位于共享内存中,则不同进程的线程就可以使用该机制。互锁操作是原子的,即整个操作是不能由相 同变量上的另一个互锁操作所中断的单元。这在抢先多线程操作系统中是很重要的,在这样的操作系统中,线程可以在从某个内存地址加载值之后但是在有机会更改 和存储该值之前被挂起。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值