Go官方设计了一个信号量库

前言

哈喽，大家好，我是asong。在写上一篇文章请勿滥用goroutine时，发现Go语言扩展包提供了一个带权重的信号量库Semaphore，使用信号量我们可以实现一个"工作池"控制一定数量的goroutine并发工作。因为对源码抱有好奇的态度，所以在周末仔细看了一下这个库并进行了解析，在这里记录一下。

目前创新互联公司已为上千家的企业提供了网站建设、域名、虚拟空间、网站托管运营、企业网站设计、海东网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。

何为信号量

要想知道一个东西是什么，我都爱去百度百科上搜一搜，输入"信号量"，这答案不就来了。

百度百科解释：

信号量(Semaphore)，有时被称为信号灯，是[多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量;一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。为了完成这个过程，需要创建一个信号量VI，然后将Acquire Semaphore VI以及Release Semaphore VI分别放置在每个关键代码段的首末端。确认这些信号量VI引用的是初始创建的信号量。

通过这段解释我们可以得知什么是信号量，其实信号量就是一种变量或者抽象数据类型，用于控制并发系统中多个进程对公共资源的访问，访问具有原子性。信号量主要分为两类：

  • 二值信号量：顾名思义，其值只有两种0或者1，相当于互斥量，当值为1时资源可用，当值为0时，资源被锁住，进程阻塞无法继续执行。
  • 计数信号量：信号量是一个任意的整数，起始时，如果计数器的计数值为0，那么创建出来的信号量就是不可获得的状态，如果计数器的计数值大于0，那么创建出来的信号量就是可获得的状态，并且总共获取的次数等于计数器的值。

信号量工作原理

信号量是由操作系统来维护的，信号量只能进行两种操作等待和发送信号，操作总结来说，核心就是PV操作：

  • P原语：P是荷兰语Proberen(测试)的首字母。为阻塞原语，负责把当前进程由运行状态转换为阻塞状态，直到另外一个进程唤醒它。操作为：申请一个空闲资源(把信号量减1)，若成功，则退出;若失败，则该进程被阻塞;
  • V原语：V是荷兰语Verhogen(增加)的首字母。为唤醒原语，负责把一个被阻塞的进程唤醒，它有一个参数表，存放着等待被唤醒的进程信息。操作为：释放一个被占用的资源(把信号量加1)，如果发现有被阻塞的进程，则选择一个唤醒之。

在信号量进行PV操作时都为原子操作，并且在PV原语执行期间不允许有中断的发生。

PV原语对信号量的操作可以分为三种情况：

  • 把信号量视为某种类型的共享资源的剩余个数，实现对一类共享资源的访问
  • 把信号量用作进程间的同步
  • 视信号量为一个加锁标志，实现对一个共享变量的访问

具体在什么场景使用本文就不在继续分析，接下来我们重点来看一下Go语言提供的扩展包Semaphore，看看它是怎样实现的。

官方扩展包Semaphore

我们之前在分析Go语言源码时总会看到这几个函数：

 
 
 
 
    
  
  
  
  
  1. func runtime_Semacquire(s *uint32) 
    2. 
  
  
  
  
  2. func runtime_SemacquireMutex(s *uint32, lifo bool, skipframes int) 
    3. 
  
  
  
  
  3. func runtime_Semrelease(s *uint32, handoff bool, skipframes int) 
    4.

这几个函数就是信号量的PV操作，不过他们都是给Go内部使用的，如果想使用信号量，那就可以使用官方的扩展包：Semaphore，这是一个带权重的信号量，接下来我们就重点分析一下这个库。

安装方法：go get -u golang.org/x/sync

数据结构

 
 
 
 
    
  
  
  
  
  1. type Weighted struct { 
    2. 
  
  
  
  
  2.  size    int64 // 设置一个最大权值 
    3. 
  
  
  
  
  3.  cur     int64 // 标识当前已被使用的资源数 
    4. 
  
  
  
  
  4.  mu      sync.Mutex // 提供临界区保护 
    5. 
  
  
  
  
  5.  waiters list.List // 阻塞等待的调用者列表 
    6. 
  
  
  
  
  6. } 
    7.

semaphore库核心结构就是Weighted，主要有4个字段：

  • size：这个代表的是最大权值，在创建Weighted对象指定
  • cur：相当于一个游标，来记录当前已使用的权值
  • mu：互斥锁，并发情况下做临界区保护
  • waiters：阻塞等待的调用者列表，使用链表数据结构保证先进先出的顺序，存储的数据是waiter对象，waiter数据结构如下：
 
 
 
 
    
  
  
  
  
  1. type waiter struct { 
    2. 
  
  
  
  
  2.  n     int64 // 等待调用者权重值 
    3. 
  
  
  
  
  3.  ready chan<- struct{} // close channel就是唤醒 
    4. 
  
  
  
  
  4. } 
    5.

这里只有两个字段：

  • n：这个就是等待调用者的权重值
  • ready：这就是一个channel，利用channel的close机制实现唤醒

semaphore还提供了一个创建Weighted对象的方法，在初始化时需要给定最大权值：

 
 
 
 
    
  
  
  
  
  1. // NewWeighted为并发访问创建一个新的加权信号量，该信号量具有给定的最大权值。 
    2. 
  
  
  
  
  2. func NewWeighted(n int64) *Weighted { 
    3. 
  
  
  
  
  3.  w := &Weighted{size: n} 
    4. 
  
  
  
  
  4.  return w 
    5. 
  
  
  
  
  5. } 
    6.

阻塞获取权值的方法 - Acquire

先直接看代码吧：

 
 
 
 
    
  
  
  
  
  1. func (s *Weighted) Acquire(ctx context.Context, n int64) error { 
    2. 
  
  
  
  
  2.  s.mu.Lock() // 加锁保护临界区 
    3. 
  
  
  
  
  3.  // 有资源可用并且没有等待获取权值的goroutine 
    4. 
  
  
  
  
  4.  if s.size-s.cur >= n && s.waiters.Len() == 0 { 
    5. 
  
  
  
  
  5.   s.cur += n // 加权 
    6. 
  
  
  
  
  6.   s.mu.Unlock() // 释放锁 
    7. 
  
  
  
  
  7.   return nil 
    8. 
  
  
  
  
  8.  } 
    9. 
  
  
  
  
  9.  // 要获取的权值n大于最大的权值了 
    10. 
  
  
  
  
  10.  if n > s.size { 
    11. 
  
  
  
  
  11.   // 先释放锁，确保其他goroutine调用Acquire的地方不被阻塞 
    12. 
  
  
  
  
  12.   s.mu.Unlock() 
    13. 
  
  
  
  
  13.   // 阻塞等待context的返回 
    14. 
  
  
  
  
  14.   <-ctx.Done() 
    15. 
  
  
  
  
  15.   return ctx.Err() 
    16. 
  
  
  
  
  16.  } 
    17. 
  
  
  
  
  17.  // 走到这里就说明现在没有资源可用了 
    18. 
  
  
  
  
  18.  // 创建一个channel用来做通知唤醒 
    19. 
  
  
  
  
  19.  ready := make(chan struct{}) 
    20. 
  
  
  
  
  20.  // 创建waiter对象 
    21. 
  
  
  
  
  21.  w := waiter{n: n, ready: ready} 
    22. 
  
  
  
  
  22.  // waiter按顺序入队 
    23. 
  
  
  
  
  23.  elem := s.waiters.PushBack(w) 
    24. 
  
  
  
  
  24.  // 释放锁，等待唤醒，别阻塞其他goroutine 
    25. 
  
  
  
  
  25.  s.mu.Unlock() 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27.  // 阻塞等待唤醒 
    28. 
  
  
  
  
  28.  select { 
    29. 
  
  
  
  
  29.  // context关闭 
    30. 
  
  
  
  
  30.  case <-ctx.Done(): 
    31. 
  
  
  
  
  31.   err := ctx.Err() // 先获取context的错误信息 
    32. 
  
  
  
  
  32.   s.mu.Lock() 
    33. 
  
  
  
  
  33.   select { 
    34. 
  
  
  
  
  34.   case <-ready: 
    35. 
  
  
  
  
  35.    // 在context被关闭后被唤醒了，那么试图修复队列，假装我们没有取消 
    36. 
  
  
  
  
  36.    err = nil 
    37. 
  
  
  
  
  37.   default: 
    38. 
  
  
  
  
  38.    // 判断是否是第一个元素 
    39. 
  
  
  
  
  39.    isFront := s.waiters.Front() == elem 
    40. 
  
  
  
  
  40.    // 移除第一个元素 
    41. 
  
  
  
  
  41.    s.waiters.Remove(elem) 
    42. 
  
  
  
  
  42.    // 如果是第一个元素且有资源可用通知其他waiter 
    43. 
  
  
  
  
  43.    if isFront && s.size > s.cur { 
    44. 
  
  
  
  
  44.     s.notifyWaiters() 
    45. 
  
  
  
  
  45.    } 
    46. 
  
  
  
  
  46.   } 
    47. 
  
  
  
  
  47.   s.mu.Unlock() 
    48. 
  
  
  
  
  48.   return err 
    49. 
  
  
  
  
  49.  // 被唤醒了 
    50. 
  
  
  
  
  50.  case <-ready: 
    51. 
  
  
  
  
  51.   return nil 
    52. 
  
  
  
  
  52.  } 
    53. 
  
  
  
  
  53. } 
    54.

注释已经加到代码中了，总结一下这个方法主要有三个流程：

  • 流程一：有资源可用时并且没有等待权值的goroutine，走正常加权流程;
  • 流程二：想要获取的权值n大于初始化时设置最大的权值了，这个goroutine永远不会获取到信号量，所以阻塞等待context的关闭;
  • 流程三：前两步都没问题的话，就说明现在系统没有资源可用了，这时就需要阻塞等待唤醒，在阻塞等待唤醒这里有特殊逻辑;
    • 特殊逻辑二：context关闭后，则根据是否有可用资源决定通知后面等待唤醒的调用者，这样做的目的其实是为了避免当不同的context控制不同的goroutine时，未关闭的goroutine不会被阻塞住，依然执行，来看这样一个例子(因为goroutine的抢占式调度，所以这个例子也会具有偶然性)：
    • 特殊逻辑一：如果在context被关闭后被唤醒了，那么就先忽略掉这个cancel，试图修复队列。
 
 
 
 
    
  
  
  
  
  1. func main()  { 
    2. 
  
  
  
  
  2.  s := semaphore.NewWeighted(3) 
    3. 
  
  
  
  
  3.  ctx,cancel := context.WithTimeout(context.Background(), time.Second * 2) 
    4. 
  
  
  
  
  4.  defer cancel() 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.  for i :=0; i < 3; i++{ 
    7. 
  
  
  
  
  7.    if i != 0{ 
    8. 
  
  
  
  
  8.     go func(num int) { 
    9. 
  
  
  
  
  9.      if err := s.Acquire(ctx,3); err != nil{ 
    10. 
  
  
  
  
  10.       fmt.Printf("goroutine： %d, err is %s\n", num, err.Error()) 
    11. 
  
  
  
  
  11.       return 
    12. 
  
  
  
  
  12.      } 
    13. 
  
  
  
  
  13.      time.Sleep(2 * time.Second) 
    14. 
  
  
  
  
  14.      fmt.Printf("goroutine： %d run over\n",num) 
    15. 
  
  
  
  
  15.      s.Release(3) 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17.     }(i) 
    18. 
  
  
  
  
  18.    }else { 
    19. 
  
  
  
  
  19.     go func(num int) { 
    20. 
  
  
  
  
  20.      ct,cancel := context.WithTimeout(context.Background(), time.Second * 3) 
    21. 
  
  
  
  
  21.      defer cancel() 
    22. 
  
  
  
  
  22.      if err := s.Acquire(ct,3); err != nil{ 
    23. 
  
  
  
  
  23.       fmt.Printf("goroutine： %d, err is %s\n", num, err.Error()) 
    24. 
  
  
  
  
  24.       return 
    25. 
  
  
  
  
  25.      } 
    26. 
  
  
  
  
  26.      time.Sleep(3 * time.Second) 
    27. 
  
  
  
  
  27.      fmt.Printf("goroutine： %d run over\n",num) 
    28. 
  
  
  
  
  28.      s.Release(3) 
    29. 
  
  
  
  
  29.     }(i) 
    30. 
  
  
  
  
  30.    } 
    31. 
  
  
  
  
  31.  
    32. 
  
  
  
  
  32.  } 
    33. 
  
  
  
  
  33.  time.Sleep(10 * time.Second) 
    34. 
  
  
  
  
  34. } 
    35.

上面的例子中goroutine:0 使用ct对象来做控制，超时时间为3s，goroutine:1和goroutine:2对象使用ctx对象来做控制，超时时间为2s，这三个goroutine占用的资源都等于最大资源数，也就是说只能有一个goruotine运行成功，另外两个goroutine都会被阻塞，因为goroutine是抢占式调度，所以我们不能确定哪个gouroutine会第一个被执行，这里我们假设第一个获取到信号量的是gouroutine:2，阻塞等待的调用者列表顺序是：goroutine:1 -> goroutine:0，因为在goroutine:2中有一个2s的延时，所以会触发ctx的超时，ctx会下发Done信号，因为goroutine:2和goroutine:1都是被ctx控制的，所以就会把goroutine:1从等待者队列中取消，但是因为goroutine:1属于队列的第一个队员，并且因为goroutine:2已经释放资源，那么就会唤醒goroutine:0继续执行，画个图表示一下：

使用这种方式可以避免goroutine永久失眠。

不阻塞获取权值的方法 - TryAcquire

 
 
 
 
    
  
  
  
  
  1. func (s *Weighted) TryAcquire(n int64) bool { 
    2. 
  
  
  
  
  2.  s.mu.Lock() // 加锁 
    3. 
  
  
  
  
  3.  // 有资源可用并且没有等待获取资源的goroutine 
    4. 
  
  
  
  
  4.  success := s.size-s.cur >= n && s.waiters.Len() == 0 
    5. 
  
  
  
  
  5.  if success { 
    6. 
  
  
  
  
  6.   s.cur += n 
    7. 
  
  
  
  
  7.  } 
    8. 
  
  
  
  
  8.  s.mu.Unlock() 
    9. 
  
  
  
  
  9.  return success 
    10. 
  
  
  
  
  10. } 
    11.

这个方法就简单很多了，不阻塞地获取权重为n的信号量，成功时返回true，失败时返回false并保持信号量不变。

释放权重

 
 
 
 
    
  
  
  
  
  1. func (s *Weighted) Release(n int64) { 
    2. 
  
  
  
  
  2.  s.mu.Lock() 
    3. 
  
  
  
  
  3.  // 释放资源 
    4. 
  
  
  
  
  4.  s.cur -= n 
    5. 
  
  
  
  
  5.  // 释放资源大于持有的资源，则会发生panic 
    6. 
  
  
  
  
  6.  if s.cur < 0 { 
    7. 
  
  
  
  
  7.   s.mu.Unlock() 
    8. 
  
  
  
  
  8.   panic("semaphore: released more than held") 
    9. 
  
  
  
  
  9.  } 
    10. 
  
  
  
  
  10.  // 通知其他等待的调用者 
    11. 
  
  
  
  
  11.  s.notifyWaiters() 
    12. 
  
  
  
  
  12.  s.mu.Unlock() 
    13. 
  
  
  
  
  13. } 
    14.

这里就是很常规的操作，主要就是资源释放，同时进行安全性判断，如果释放资源大于持有的资源，则会发生panic。

唤醒waiter

在Acquire和Release方法中都调用了notifyWaiters，我们来分析一下这个方法：

 
 
 
 
    
  
  
  
  
  1. func (s *Weighted) notifyWaiters() { 
    2. 
  
  
  
  
  2.  for { 
    3. 
  
  
  
  
  3.   // 获取等待调用者队列中的队员 
    4. 
  
  
  
  
  4.   next := s.waiters.Front() 
    5. 
  
  
  
  
  5.   // 没有要通知的调用者了 
    6. 
  
  
  
  
  6.   if next == nil { 
    7. 
  
  
  
  
  7.    break // No more waiters blocked. 
    8. 
  
  
  
  
  8.   } 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.   // 断言出waiter信息 
    11. 
  
  
  
  
  11.   w := next.Value.(waiter) 
    12. 
  
  
  
  
  12.   if s.size-s.cur < w.n { 
    13. 
  
  
  
  
  13.    // 没有足够资源为下一个调用者使用时，继续阻塞该调用者，遵循先进先出的原则， 
    14. 
  
  
  
  
  14.    // 避免需要资源数比较大的waiter被饿死 
    15. 
  
  
  
  
  15.    // 
    16. 
  
  
  
  
  16.    // 考虑一个场景，使用信号量作为读写锁，现有N个令牌，N个reader和一个writer 
    17. 
  
  
  
  
  17.    // 每个reader都可以通过Acquire（1）获取读锁，writer写入可以通过Acquire（N）获得写锁定 
    18. 
  
  
  
  
  18.    // 但不包括所有的reader，如果我们允许reader在队列中前进，writer将会饿死-总是有一个令牌可供每个reader 
    19. 
  
  
  
  
  19.    break 
    20. 
  
  
  
  
  20.   } 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22.   // 获取资源 
    23. 
  
  
  
  
  23.   s.cur += w.n 
    24. 
  
  
  
  
  24.   // 从waiter列表中移除 
    25. 
  
  
  
  
  25.   s.waiters.Remove(next) 
    26. 
  
  
  
  
  26.   // 使用channel的close机制唤醒waiter 
    27. 
  
  
  
  
  27.   close(w.ready) 
    28. 
  
  
  
  
  28.  } 
    29. 
  
  
  
  
  29. } 
    30.

这里只需要注意一个点：唤醒waiter采用先进先出的原则，避免需要资源数比较大的waiter被饿死。

何时使用Semaphore

到这里我们就把Semaphore的源代码看了一篇，代码行数不多，封装的也很巧妙，那么我们该什么时候选择使用它呢?

目前能想到一个场景就是Semaphore配合上errgroup实现一个"工作池"，使用Semaphore限制goroutine的数量，配合上errgroup做并发控制，示例如下：

 
 
 
 
    
  
  
  
  
  1. const ( 
    2. 
  
  
  
  
  2.  limit = 2 
    3. 
  
  
  
  
  3. )  
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. func main()  { 
    6. 
  
  
  
  
  6.  serviceName := []string{ 
    7. 
  
  
  
  
  7.   "cart", 
    8. 
  
  
  
  
  8.   "order", 
    9. 
  
  
  
  
  9.   "account", 
    10. 
  
  
  
  
  10.   "item", 
    11. 
  
  
  
  
  11.   "menu", 
    12. 
  
  
  
  
  12.  } 
    13. 
  
  
  
  
  13.  eg,ctx := errgroup.WithContext(context.Background()) 
    14. 
  
  
  
  
  14.  s := semaphore.NewWeighted(limit) 
    15. 
  
  
  
  
  15.  for index := range serviceName{ 
    16. 
  
  
  
  
  16.   name := serviceName[index] 
    17. 
  
  
  
  
  17.   if err := s.Acquire(ctx,1); err != nil{ 
    18. 
  
  
  
  
  18.    fmt.Printf("Acquire failed and err is %s\n", err.Error()) 
    19. 
  
  
  
  
  19.    break 
    20. 
  
  
  
  
  20.   } 
    21. 
  
  
  
  
  21.   eg.Go(func() error { 
    22. 
  
  
  
  
  22.    defer s.Release(1) 
    23. 
  
  
  
  
  23.    return callService(name) 
    24. 
  
  
  
  
  24.   }) 
    25. 
  
  
  
  
  25.  } 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27.  if err := eg.Wait(); err != nil{ 
    28. 
  
  
  
  
  28.   fmt.Printf("err is %s\n", err.Error()) 
    29. 
  
  
  
  
  29.   return 
    30. 
  
  
  
  
  30.  } 
    31. 
  
  
  
  
  31.  fmt.Printf("run success\n") 
    32. 
  
  
  
  
  32. } 
    33. 
  
  
  
  
  33.  
    34. 
  
  
  
  
  34. func callService(name string) error { 
    35. 
  
  
  
  
  35.  fmt.Println("call ",name) 
    36. 
  
  
  
  
  36.  time.Sleep(1 * time.Second) 
    37. 
  
  
  
  
  37.  return nil 
    38. 
  
  
  
  
  38. } 
    39.

结果如下：

 
 
 
 
    
  
  
  
  
  1. call  order 
    2. 
  
  
  
  
  2. call  cart 
    3. 
  
  
  
  
  3. call  account 
    4. 
  
  
  
  
  4. call  item 
    5. 
  
  
  
  
  5. call  menu 
    6. 
  
  
  
  
  6. run success 
    7.

总结

本文我们主要赏析了Go官方扩展库Semaphore的实现，他的设计思路简单，仅仅用几十行就完成了完美的封装，值得我们借鉴学习。不过在实际业务场景中，我们使用信号量的场景并不多，大多数场景我们都可以使用channel来替代，但是有些场景使用Semaphore来实现会更好，比如上篇文章【[警惕] 请勿滥用goroutine】我们使用channel+sync来控制goroutine数量，这种实现方式并不好，因为实际已经起来了多个goroutine，只不过控制了工作的goroutine数量，如果改用semaphore实现才是真正的控制了goroutine数量。

文中代码已上传github：https://github.com/asong2020/Golang_Dream/blob/master/code_demo/semaphore_demo/semaphore.go，欢迎star。

网页标题：Go官方设计了一个信号量库
URL网址：http://www.mswzjz.com/qtweb/news40/204240.html

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

广告

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

猜你还喜欢下面的内容

定制开发知识

分类信息网

做手机网站　　 　平昌做网站　　 　企业邮箱　　 　成都响应式网站建设公司　　 　广汉锦华橡塑　　 　成都全网营销推广　　 　东方电机技改服务有限公司　　 　广汉锦华　　 　乐山做网站　　 　微信小程序开发　　 　广告品牌策划设计　　 　芦山网站建设　　 　西云服务器托管　　 　成都响应式网站建设公司　　 　华泰海航　　 　东电技改　　 　联通服务器托管　　 　成都企业网站定制　　 　广安网站制作公司　　 　腾讯云香港空间