多核编程中的条件同步模式

开发 前端
在多线程编程中,当对共享资源进行操作时,需要使用同步(通常是锁或原子操作)来进行保护,以避免数据竞争问题。不幸的是,同步操作的开销非常大,比如对一个整数变量进行加法操作,那么同步操作的开销是加法操作的上百倍以上。

在多线程编程中,当对共享资源进行操作时,需要使用同步(通常是锁或原子操作)来进行保护,以避免数据竞争问题。不幸的是,同步操作的开销非常大,比如对一个整数变量进行加法操作,那么同步操作的开销是加法操作的上百倍以上。

有没有办法可以减少这种同步操作的开销呢?如果能设计出更快的锁或更快的原子操作来,那么这种开销自然就减少了。以目前的技术来看,最快速的原子操作耗时也是普通加法操作的上百倍,所以从这方面着手是非常困难的。

那么能不能从软件算法的角度来减少同步操作的开销呢?答案是当然可以,基本思想是减少使用同步的次数,比如原来要使用同步1000次,现在改为在满足一定条件下才使用同步,只需要10次,那么同步的开销平摊下来就被减少了100倍,效率大大提高了。下面先来看一个共享队列例子。

一个普通的共享队列通常都是使用锁来实现,当然也有用CAS原子操作来实现的,这里只讨论用锁来实现的共享队列。

在有锁保护的共享队列中,在队列的进队和出队操作时,通常都是使用锁来进行保护的,一个典型的使用锁保护的出队操作伪代码如下:

  1. template class <T> 
  2.  
  3.       Locked_DeQueue(T &data) 
  4.  
  5.       { 
  6.  
  7.              Lock(); 
  8.  
  9.              DeQueue(data);  //调用串行的出队操作 
  10.  
  11.              Unlock(); 
  12.  
  13.       } 

在使用上面的Locked_DeQueue()函数时,每调用一次,就会发生一次锁操作。事实上,并不是每次都需要加锁操作的,比如队列为空时,这时实际上是不需要进行出队操作的,完全可以采取的一定的方法避免锁操作,但是采用上面的Locked_DeQueue()函数无法避免锁操作,这就需要对上面的函数进行改进。

一种最容易想到的方面就是先判断队列是否为空,如果不为空才使用锁保护进行出队操作。代码如下:

  1. template class <T> 
  2.  
  3.        Locked_DeQueue_a(T &data) 
  4.  
  5.        { 
  6.  
  7.               If ( !IsEmpty() ) 
  8.  
  9.               { 
  10.  
  11.                      Lock(); 
  12.  
  13.                      DeQueue(data);  //调用串行的出队操作 
  14.  
  15.                      Unlock(); 
  16.  
  17.               } 
  18.  
  19.        } 

上面的Locked_DeQueue_a()函数的一个关键之处是IsEmpty()函数必须不能使用锁操作,否则不仅没有减少同步开销,反而将同步开销增大了近一倍。

如何来使得IsEmtpy()函数不用锁操作呢,以数组实现的环行队列为例,在判断队列是否为空时,其基本方法是判断队首指针是否等于队尾指针。伪代码如下:

  1. INT IsEmpty() 
  2.        Lock() 
  3.  
  4.        if ( 队首指针 == 队尾指针 ) 
  5.  
  6.        { 
  7.               Unlock(); 
  8.  
  9.               return 1; //为空 
  10.        } 
  11.  
  12.        else 
  13.  
  14.        {     
  15.               Unlock(); 
  16.  
  17.               return 0; //非空 
  18.        } 
  19.  

由于队首指针和队尾指针在进队或出队操作时会发生改变,因此在上面的IsEmpty()函数中,需要使用锁保护,那么如何去掉这层锁保护呢?

基本的方法是设一个标志变量EmptyFlag,在进队和出队操作中,当队列为空时,标志变量的值置为1,队列非空时,标志变量的值置为0。这样判断队列是否为空就可以通过EmptyFlag单个变量来进行,而单个变量的读写可以使用原子操作来实现,使得读操作和普通操作一样不存在同步操作。

下面是使用EmptyFlag变量实现的出队操作。

  1. template class <T> 
  2.        Locked_DeQueue_b(T &data) 
  3.  
  4.        {
  5.               if ( EmptyFlag ) 
  6.               { 
  7.                      return; 
  8.               } 
  9.               Lock(); 
  10.  
  11.               if ( !EmptyFlag )  //Lock()前, 其他线程可能修改了标志 
  12.  
  13.               { 
  14.                      DeQueue(data);  //调用串行的出队操作 
  15.  
  16.                   if ( 队首指针 == 队尾指针 ) 
  17.  
  18.                   { 
  19.                       //出队后,队列变空,使用原子操作将EmptyFlag置为1 
  20.  
  21.                       AtomicIncrement(&EmptyFlag); 
  22.                   } 
  23.               } 
  24.  
  25.               Unlock(); 
  26.        } 

队列的是否为空函数可以使用下面的完全不需要同步的实现。

  1. INT IsEmpty() 
  2.  
  3.        { 
  4.  
  5.               return EmptyFlag; 
  6.  
  7.        } 

Locked_DeQueue_b()函数的实现可以看出,如果队列本来为空的情况下,它只判断一个EmptyFlag就返回了,不会调用锁操作,减少了同步使用的次数,并且在IsEmpty()函数中,根本不需要使用同步,这对于那些需要频繁判断队列是否为空的使用场景,有很好的效果。

比 如对于动态任务调度,假设使用普通的有锁的共享队列。当一个线程私有队列为空时,需要去偷取其他线程的共享队列中的任务,如果偷取的队列为空则发生了一次 锁操作,此时需要再偷另外一个队列的任务,如果这个队列仍然为空则又要一次锁操作,一次获取任务的操作中将可能出现多次加锁解锁的情况。通过上面讲的条件 同步方法就可以在偷取取一个任务时,只要一次锁操作就可以实现。

上面讲的条件同步模式非常适应于具有状态机性质的场合,只有在发生状态切换(例如队列中空或非空的状态的切换)时才使用同步,通过对状态变量(例如EmptyFlag)的操作来替代其他非状态变量(例如队首指针和队尾指针)的操作,减少同步的使用。

原文链接:http://blog.csdn.net/drzhouweiming/article/details/4006899

责任编辑:陈四芳 来源: blog.csdn.net
相关推荐

2013-12-18 16:12:26

多核编程

2013-12-18 16:18:08

多核线程

2013-12-16 15:04:51

多核编程

2013-12-16 15:09:15

多核负载

2011-08-05 16:41:48

iOS 队列 内存

2013-12-18 13:26:24

多核编程

2011-08-22 11:07:16

IOS 开发多核内存

2009-12-14 14:43:50

Linux内核

2012-04-10 10:04:26

并行编程

2014-07-30 10:08:13

Python反模式

2013-12-16 11:18:42

多核

2011-07-21 17:40:43

iOS 多核 内存

2024-02-20 07:32:18

Rsync远程同步工具传输数据

2013-12-18 17:29:10

多核并行

2018-06-14 09:38:53

Linux多核编程

2013-12-18 15:27:21

编程无锁

2009-09-09 11:37:08

Scala的模式匹配

2013-03-08 09:33:25

JavaScript同步异步

2021-10-13 07:48:23

Options模式编程

2011-03-24 09:23:43

.NET 4多核并行
点赞
收藏

51CTO技术栈公众号