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

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

10年积累的成都网站建设、网站设计经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站设计后付款的网站建设流程，更有环翠免费网站建设让你可以放心的选择与我们合作。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

标题名称：多核编程中的条件同步模式
分享链接：http://www.shufengxianlan.com/qtweb/news10/70560.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

营销型网站建设知识

行业网站建设

高端网站设计　　 　广安网站建设　　 　成都网站建设　　 　雅安网站建设　　 　名片印刷　　 　内江网站建设　　 　响应式网站建设公司　　 　四川内江电信机房　　 　名片　　 　大吉雪茄　　 　西信服务器托管　　 　成都钢筋机械设备　　 　免备案虚拟主机空间　　 　成都画册设计公司　　 　乐山中领科信　　 　成都导视系统设计　　 　成都网站制作　　 　成都网站建设　　 　梓潼做网站　　 　资阳网站建设