gring

并发安全环结构，循环双向链表。

使用场景：

ring这种数据结构在底层开发中用得比较多一些，如：并发锁控制、缓冲区控制。ring的特点在于，其必须有固定的大小，当不停地往ring中追加写数据时，如果数据大小超过容量大小，新值将会将旧值覆盖。

使用方式：

  1. import "gitee.com/johng/gf/g/container/gring"

方法列表：godoc.org/github.com/johng-cn/gf/g/container/gring

  1. type Ring
  2.     func New(cap int) *Ring
  3.     func (r *Ring) Cap() int
  4.     func (r *Ring) Len() int
  5.     func (r *Ring) Link(s *Ring) *Ring
  6.     func (r *Ring) LockIteratorNext(f func(item *ring.Ring) bool)
  7.     func (r *Ring) LockIteratorPrev(f func(item *ring.Ring) bool)
  8.     func (r *Ring) Move(n int) *Ring
  9.     func (r *Ring) Next() *Ring
  10.     func (r *Ring) Prev() *Ring
  11.     func (r *Ring) Put(value interface{}) *Ring
  12.     func (r *Ring) RLockIteratorNext(f func(value interface{}) bool)
  13.     func (r *Ring) RLockIteratorPrev(f func(value interface{}) bool)
  14.     func (r *Ring) Set(value interface{}) *Ring
  15.     func (r *Ring) SliceNext() []interface{}
  16.     func (r *Ring) SlicePrev() []interface{}
  17.     func (r *Ring) Unlink(n int) *Ring
  18.     func (r *Ring) Val() interface{}

从以上方法可以看出，gring支持链式操作。

使用示例，约瑟夫问题

我们使用ring来模拟一下约瑟夫问题：

著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。问题是，给定了和，一开始要站在什么地方才能避免被处决？

  1. package main
  3. import (
  4.     "fmt"
  5.     "gitee.com/johng/gf/g/container/gring"
  6. )
  8. type Player struct {
  9.     position int  // 位置
  10.     alive    bool // 是否存活
  11. }
  13. const (
  14.     playerCount = 41  // 玩家人数
  15.     startPos    = 1   // 开始报数位置
  16. )
  18. var (
  19.     deadline = 3
  20. )
  22. func main() {
  23.     // 关闭并发安全，当前场景没有必要
  24.     r := gring.New(playerCount, false)
  26.     // 设置所有玩家初始值
  27.     for i := 1; i <= playerCount; i++ {
  28.         r.Put(&Player{i, true})
  29.     }
  31.     // 如果开始报数的位置不为1，则设置开始位置
  32.     if startPos > 1 {
  33.         r.Move(startPos - 1)
  34.     }
  36.     counter   := 1  // 报数从1开始，因为下面的循环从第二个开始计算
  37.     deadCount := 0  // 死亡人数，初始值为0
  39.     // 直到所有人都死亡，否则循环一直执行
  40.     for deadCount < playerCount {
  41.         // 跳到下一个人
  42.         r.Next() 
  44.         // 如果是活着的人，则报数
  45.         if r.Val().(*Player).alive {
  46.             counter++
  47.         }
  49.         // 如果报数为deadline，则此人淘汰出局
  50.         if counter == deadline {
  51.             r.Val().(*Player).alive = false
  52.             fmt.Printf("Player %d died!\n", r.Val().(*Player).position)
  53.             deadCount++
  54.             counter = 0
  55.         }
  56.     }
  57. }

执行后，输出结果为：

  1. Player 3 died!
  2. Player 6 died!
  3. Player 9 died!
  4. Player 12 died!
  5. Player 15 died!
  6. Player 18 died!
  7. Player 21 died!
  8. Player 24 died!
  9. Player 27 died!
  10. Player 30 died!
  11. Player 33 died!
  12. Player 36 died!
  13. Player 39 died!
  14. Player 1 died!
  15. Player 5 died!
  16. Player 10 died!
  17. Player 14 died!
  18. Player 19 died!
  19. Player 23 died!
  20. Player 28 died!
  21. Player 32 died!
  22. Player 37 died!
  23. Player 41 died!
  24. Player 7 died!
  25. Player 13 died!
  26. Player 20 died!
  27. Player 26 died!
  28. Player 34 died!
  29. Player 40 died!
  30. Player 8 died!
  31. Player 17 died!
  32. Player 29 died!
  33. Player 38 died!
  34. Player 11 died!
  35. Player 25 died!
  36. Player 2 died!
  37. Player 22 died!
  38. Player 4 died!
  39. Player 35 died!
  40. Player 16 died!
  41. Player 31 died!

可以看到16和31是最后两个出队列的，因此Josephus将他的朋友与自己安排在第16个与第31个位置是安全的。