并发状态

  • 共享值
  • 竞争条件（race condition）

Go 的互斥锁（mutex）

  • mutex = mutual exclusive
  • Lock()，Unlock()
  • sync 包 
  1. package main
  3. import "sync"
  5. var mu sync.Mutex
  7. func main() {
  8.     mu.Lock()
  9.     defer mu.Unlock()
  10.     // The lock is held until we return from the function.
  11. }
  • 互斥锁定义在被保护的变量之上 
  1. package main
  3. import "sync"
  5. // Visited tracks whether web pages have been visited.
  6. // Its methods may be used concurrently with one another.
  7. type Visited struct {
  8.     // mu guards the visited map.
  9.     mu      sync.Mutex
  10.     visited map[string]int
  11. }
  13. // VisitLink tracks that the page with the given URL has
  14. // been visited, and returns the updated link count.
  15. func (v *Visited) VisitLink(url string) int {
  16.     v.mu.Lock()
  17.     defer v.mu.Unlock()
  18.     count := v.visited[url]
  19.     count++
  20.     v.visited[url] = count
  21.     return count
  22. }
  24. func main() {
  25. }

互斥锁的隐患

  • 死锁
  • 为保证互斥锁的安全使用，我们须遵守以下规则：
    • 尽可能的简化互斥锁保护的代码
    • 对每一份共享状态只使用一个互斥锁

长时间运行的工作进程

  • 工作进程（worker）
    • 通常会被写成包含 select 语句的 for 循环。
  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. func main() {
  9.     go worker()
  10.     time.Sleep(5 * time.Second)
  11. }
  12. func worker() {
  13.     n := 0
  14.     next := time.After(time.Second)
  15.     for {
  16.         select {
  17.         case <-next:
  18.             n++
  19.             fmt.Println(n)
  20.             next = time.After(time.Second)
  21.         }
  22.     }
  23. }
  1. package main
  3. import (
  4.     "fmt"
  5.     "image"
  6.     "time"
  7. )
  9. func main() {
  10.     go worker()
  11.     time.Sleep(5 * time.Second)
  12. }
  13. func worker() {
  14.     pos := image.Point{X: 10, Y: 10}
  15.     direction := image.Point{X: 1, Y: 0}
  16.     next := time.After(time.Second)
  17.     for {
  18.         select {
  19.         case <-next:
  20.             pos = pos.Add(direction)
  21.             fmt.Println("current position is ", pos)
  22.             next = time.After(time.Second)
  23.         }
  24.     }
  25. }
  1. package main
  3. import (
  4.     "image"
  5.     "log"
  6.     "time"
  7. )
  9. func main() {
  10.     r := NewRoverDriver()
  11.     time.Sleep(3 * time.Second)
  12.     r.Left()
  13.     time.Sleep(3 * time.Second)
  14.     r.Right()
  15.     time.Sleep(3 * time.Second)
  16. }
  18. // RoverDriver drives a rover around the surface of Mars.
  19. type RoverDriver struct {
  20.     commandc chan command
  21. }
  23. // NewRoverDriver starts a new RoverDriver and returns it.
  24. func NewRoverDriver() *RoverDriver {
  25.     r := &RoverDriver{
  26.         commandc: make(chan command),
  27.     }
  28.     go r.drive()
  29.     return r
  30. }
  32. type command int
  34. const (
  35.     right = command(0)
  36.     left  = command(1)
  37. )
  39. // drive is responsible for driving the rover. It
  40. // is expected to be started in a goroutine.
  41. func (r *RoverDriver) drive() {
  42.     pos := image.Point{X: 0, Y: 0}
  43.     direction := image.Point{X: 1, Y: 0}
  44.     updateInterval := 250 * time.Millisecond
  45.     nextMove := time.After(updateInterval)
  46.     for {
  47.         select {
  48.         case c := <-r.commandc:
  49.             switch c {
  50.             case right:
  51.                 direction = image.Point{
  52.                     X: -direction.Y,
  53.                     Y: direction.X,
  54.                 }
  55.             case left:
  56.                 direction = image.Point{
  57.                     X: direction.Y,
  58.                     Y: -direction.X,
  59.                 }
  60.             }
  61.             log.Printf("new direction %v", direction)
  62.         case <-nextMove:
  63.             pos = pos.Add(direction)
  64.             log.Printf("moved to %v", pos)
  65.             nextMove = time.After(updateInterval)
  66.         }
  67.     }
  68. }
  70. // Left turns the rover left (90° counterclockwise).
  71. func (r *RoverDriver) Left() {
  72.     r.commandc <- left
  73. }
  75. // Right turns the rover right (90° clockwise).
  76. func (r *RoverDriver) Right() {
  77.     r.commandc <- right
  78. }

事件循环和 goroutine

  • 事件循环（event loop）
  • 中心循环（central loop）
  • Go 通过提供 goroutine 作为核心概念，消除了对中心循环的需求。

作业题

  • 以例子 31.5 为基础，修改代码使得每次移动之间的间隔增加半秒。 
  1. package main
  3. import (
  4.     "fmt"
  5.     "image"
  6.     "time"
  7. )
  9. func main() {
  10.     go worker()
  11.     time.Sleep(5 * time.Second)
  12. }
  14. func worker() {
  15.     pos := image.Point{X: 10, Y: 10}
  16.     direction := image.Point{X: 1, Y: 0}
  17.     delay := time.Second
  18.     next := time.After(delay)
  19.     for {
  20.         select {
  21.         case <-next:
  22.             pos = pos.Add(direction)
  23.             fmt.Println("current position is ", pos)
  24.             delay += time.Second / 2
  25.             next = time.After(delay)
  26.         }
  27.     }
  28. }
  • 以 RoverDriver 类型为基础，定义 Start 方法、Stop 方法和对应的命令，然后修改代码使得探测器可以接受这两个新命令。 
  1. package main
  3. import (
  4.     "image"
  5.     "log"
  6.     "time"
  7. )
  9. func main() {
  10.     r := NewRoverDriver()
  11.     time.Sleep(3 * time.Second)
  12.     r.Left()
  13.     time.Sleep(3 * time.Second)
  14.     r.Right()
  15.     time.Sleep(3 * time.Second)
  16.     r.Stop()
  17.     time.Sleep(3 * time.Second)
  18.     r.Start()
  19.     time.Sleep(3 * time.Second)
  20. }
  22. // RoverDriver drives a rover around the surface of Mars.
  23. type RoverDriver struct {
  24.     commandc chan command
  25. }
  27. // NewRoverDriver starts a new RoverDriver and returns it.
  28. func NewRoverDriver() *RoverDriver {
  29.     r := &RoverDriver{
  30.         commandc: make(chan command),
  31.     }
  32.     go r.drive()
  33.     return r
  34. }
  36. type command int
  38. const (
  39.     right = command(0)
  40.     left  = command(1)
  41.     start = command(2)
  42.     stop  = command(3)
  43. )
  45. // drive is responsible for driving the rover. It
  46. // is expected to be started in a goroutine.
  47. func (r *RoverDriver) drive() {
  48.     pos := image.Point{X: 0, Y: 0}
  49.     direction := image.Point{X: 1, Y: 0}
  50.     updateInterval := 250 * time.Millisecond
  51.     nextMove := time.After(updateInterval)
  52.     speed := 1
  53.     for {
  54.         select {
  55.         case c := <-r.commandc:
  56.             switch c {
  57.             case right:
  58.                 direction = image.Point{
  59.                     X: -direction.Y,
  60.                     Y: direction.X,
  61.                 }
  62.             case left:
  63.                 direction = image.Point{
  64.                     X: direction.Y,
  65.                     Y: -direction.X,
  66.                 }
  67.             case stop:
  68.                 speed = 0
  69.             case start:
  70.                 speed = 1
  71.             }
  72.             log.Printf("new direction %v; speed %d", direction, speed)
  73.         case <-nextMove:
  74.             pos = pos.Add(direction.Mul(speed))
  75.             log.Printf("moved to %v", pos)
  76.             nextMove = time.After(updateInterval)
  77.         }
  78.     }
  79. }
  81. // Left turns the rover left (90° counterclockwise).
  82. func (r *RoverDriver) Left() {
  83.     r.commandc <- left
  84. }
  86. // Right turns the rover right (90° clockwise).
  87. func (r *RoverDriver) Right() {
  88.     r.commandc <- right
  89. }
  91. // Stop halts the rover.
  92. func (r *RoverDriver) Stop() {
  93.     r.commandc <- stop
  94. }
  96. // Start gets the rover moving.
  97. func (r *RoverDriver) Start() {
  98.     r.commandc <- start
  99. }