第七部分习题 - 图1

    第七部分习题 - 图2

    第七部分习题 - 图3

    gridrover.go

    1. package main
    3. import (
    4.     "fmt"
    5.     "image"
    6.     "log"
    7.     "math/rand"
    8.     "sync"
    9.     "time"
    10. )
    12. func main() {
    13.     gridSize := image.Point{X: 20, Y: 10}
    14.     grid := NewMarsGrid(gridSize)
    15.     rover := make([]*RoverDriver, 5)
    16.     for i := range rover {
    17.         rover[i] = startDriver(fmt.Sprint("rover", i), grid)
    18.     }
    19.     time.Sleep(10 * time.Second)
    20. }
    22. func startDriver(name string, grid *MarsGrid) *RoverDriver {
    23.     var o *Occupier
    24.     // Try a random point; continue until we've found one that's
    25.     // not currently occupied.
    26.     for o == nil {
    27.         startPoint := image.Point{X: rand.Intn(grid.Size().X), Y: rand.Intn(grid.Size().Y)}
    28.         o = grid.Occupy(startPoint)
    29.     }
    30.     return NewRoverDriver(name, o)
    31. }
    33. // RoverDriver drives a rover around the surface of Mars.
    34. type RoverDriver struct {
    35.     commandc chan command
    36.     occupier *Occupier
    37.     name     string
    38. }
    40. // NewRoverDriver starts a new RoverDriver and returns it.
    41. func NewRoverDriver(name string, occupier *Occupier) *RoverDriver {
    42.     r := &RoverDriver{
    43.         commandc: make(chan command),
    44.         occupier: occupier,
    45.         name:     name,
    46.     }
    47.     go r.drive()
    48.     return r
    49. }
    51. type command int
    53. const (
    54.     right command = 0
    55.     left  command = 1
    56. )
    58. // drive is responsible for driving the rover. It
    59. // is expected to be started in a goroutine.
    60. func (r *RoverDriver) drive() {
    61.     log.Printf("%s initial position %v", r.name, r.occupier.Pos())
    62.     direction := image.Point{X: 1, Y: 0}
    63.     updateInterval := 250 * time.Millisecond
    64.     nextMove := time.After(updateInterval)
    65.     for {
    66.         select {
    67.         case c := <-r.commandc:
    68.             switch c {
    69.             case right:
    70.                 direction = image.Point{
    71.                     X: -direction.Y,
    72.                     Y: direction.X,
    73.                 }
    74.             case left:
    75.                 direction = image.Point{
    76.                     X: direction.Y,
    77.                     Y: -direction.X,
    78.                 }
    79.             }
    80.             log.Printf("%s new direction %v", r.name, direction)
    81.         case <-nextMove:
    82.             nextMove = time.After(updateInterval)
    83.             newPos := r.occupier.Pos().Add(direction)
    84.             if r.occupier.MoveTo(newPos) {
    85.                 log.Printf("%s moved to %v", r.name, newPos)
    86.                 // Successfully moved to new position.
    87.                 break
    88.             }
    89.             log.Printf("%s blocked trying to move from %v to %v", r.name, r.occupier.Pos(), newPos)
    90.             // Pick one of the other directions randomly.
    91.             // Next time round, we'll try to move in the new
    92.             // direction.
    93.             dir := rand.Intn(3) + 1
    94.             for i := 0; i < dir; i++ {
    95.                 direction = image.Point{
    96.                     X: -direction.Y,
    97.                     Y: direction.X,
    98.                 }
    99.             }
    100.             log.Printf("%s new random direction %v", r.name, direction)
    101.         }
    102.     }
    103. }
    105. // Left turns the rover left (90° anticlockwise).
    106. func (r *RoverDriver) Left() {
    107.     r.commandc <- left
    108. }
    110. // Right turns the rover right (90° clockwise).
    111. func (r *RoverDriver) Right() {
    112.     r.commandc <- right
    113. }
    115. // MarsGrid represents a grid of some of the surface
    116. // of Mars. It may be used concurrently by different
    117. // goroutines.
    118. type MarsGrid struct {
    119.     bounds image.Rectangle
    120.     mu     sync.Mutex
    121.     cells  [][]cell
    122. }
    124. // SensorData holds information about whats in
    125. // a point in the grid.
    126. type SensorData struct {
    127.     Life int
    128. }
    130. type cell struct {
    131.     groundData SensorData
    132.     occupier   *Occupier
    133. }
    135. // NewMarsGrid returns a new MarsGrid of the
    136. // given size.
    137. func NewMarsGrid(size image.Point) *MarsGrid {
    138.     grid := &MarsGrid{
    139.         bounds: image.Rectangle{
    140.             Max: size,
    141.         },
    142.         cells: make([][]cell, size.Y),
    143.     }
    144.     for i := range grid.cells {
    145.         grid.cells[i] = make([]cell, size.X)
    146.     }
    147.     return grid
    148. }
    150. // Size returns the size of the grid.
    151. func (g *MarsGrid) Size() image.Point {
    152.     return g.bounds.Max
    153. }
    155. // Occupy occupies a cell at the given point in the grid. It
    156. // returns nil if the point is already or the point is outside
    157. // the grid. Otherwise it returns a value that can be used
    158. // to move to different places on the grid.
    159. func (g *MarsGrid) Occupy(p image.Point) *Occupier {
    160.     g.mu.Lock()
    161.     defer g.mu.Unlock()
    162.     cell := g.cell(p)
    163.     if cell == nil || cell.occupier != nil {
    164.         return nil
    165.     }
    166.     cell.occupier = &Occupier{
    167.         grid: g,
    168.         pos:  p,
    169.     }
    170.     return cell.occupier
    171. }
    173. func (g *MarsGrid) cell(p image.Point) *cell {
    174.     if !p.In(g.bounds) {
    175.         return nil
    176.     }
    177.     return &g.cells[p.Y][p.X]
    178. }
    180. // Occupier represents an occupied cell in the grid.
    181. type Occupier struct {
    182.     grid *MarsGrid
    183.     pos  image.Point
    184. }
    186. // MoveTo moves the occupier to a different cell in the grid.
    187. // It reports whether the move was successful
    188. // It might fail because it was trying to move outside
    189. // the grid or because the cell it's trying to move into
    190. // is occupied. If it fails, the occupier remains in the same place.
    191. func (o *Occupier) MoveTo(p image.Point) bool {
    192.     o.grid.mu.Lock()
    193.     defer o.grid.mu.Unlock()
    194.     newCell := o.grid.cell(p)
    195.     if newCell == nil || newCell.occupier != nil {
    196.         return false
    197.     }
    198.     o.grid.cell(o.pos).occupier = nil
    199.     newCell.occupier = o
    200.     o.pos = p
    201.     return true
    202. }
    204. // Sense returns sensory data from the current cell.
    205. func (o *Occupier) Sense() SensorData {
    206.     o.grid.mu.Lock()
    207.     defer o.grid.mu.Unlock()
    208.     return o.grid.cell(o.pos).groundData
    209. }
    211. // Pos returns the current grid position of the occupier.
    212. func (o *Occupier) Pos() image.Point {
    213.     return o.pos
    214. }

    lifeonmars.go

    1. package main
    3. import (
    4.     "fmt"
    5.     "image"
    6.     "log"
    7.     "math/rand"
    8.     "sync"
    9.     "time"
    10. )
    12. func main() {
    13.     marsToEarth := make(chan []Message)
    14.     go earthReceiver(marsToEarth)
    16.     gridSize := image.Point{X: 20, Y: 10}
    17.     grid := NewMarsGrid(gridSize)
    18.     rover := make([]*RoverDriver, 5)
    19.     for i := range rover {
    20.         rover[i] = startDriver(fmt.Sprint("rover", i), grid, marsToEarth)
    21.     }
    22.     time.Sleep(60 * time.Second)
    23. }
    25. // Message holds a message as sent from Mars to Earth.
    26. type Message struct {
    27.     Pos       image.Point
    28.     LifeSigns int
    29.     Rover     string
    30. }
    32. const (
    33.     // The length of a Mars day.
    34.     dayLength = 24 * time.Second
    35.     // The length of time per day during which
    36.     // messages can be transmitted from a rover to Earth.
    37.     receiveTimePerDay = 2 * time.Second
    38. )
    40. // earthReceiver receives messages sent from Mars.
    41. // As connectivity is limited, it only receives messages
    42. // for some time every Mars day.
    43. func earthReceiver(msgc chan []Message) {
    44.     for {
    45.         time.Sleep(dayLength - receiveTimePerDay)
    46.         receiveMarsMessages(msgc)
    47.     }
    48. }
    50. // receiveMarsMessages receives messages sent from Mars
    51. // for the given duration.
    52. func receiveMarsMessages(msgc chan []Message) {
    53.     finished := time.After(receiveTimePerDay)
    54.     for {
    55.         select {
    56.         case <-finished:
    57.             return
    58.         case ms := <-msgc:
    59.             for _, m := range ms {
    60.                 log.Printf("earth received report of life sign level %d from %s at %v", m.LifeSigns, m.Rover, m.Pos)
    61.             }
    62.         }
    63.     }
    64. }
    66. func startDriver(name string, grid *MarsGrid, marsToEarth chan []Message) *RoverDriver {
    67.     var o *Occupier
    68.     // Try a random point; continue until we've found one that's
    69.     // not currently occupied.
    70.     for o == nil {
    71.         startPoint := image.Point{X: rand.Intn(grid.Size().X), Y: rand.Intn(grid.Size().Y)}
    72.         o = grid.Occupy(startPoint)
    73.     }
    74.     return NewRoverDriver(name, o, marsToEarth)
    75. }
    77. // Radio represents a radio transmitter that can send
    78. // message to Earth.
    79. type Radio struct {
    80.     fromRover chan Message
    81. }
    83. // SendToEarth sends a message to Earth. It always
    84. // succeeds immediately - the actual message
    85. // may be buffered and actually transmitted later.
    86. func (r *Radio) SendToEarth(m Message) {
    87.     r.fromRover <- m
    88. }
    90. // NewRadio returns a new Radio instance that sends
    91. // messages on the toEarth channel.
    92. func NewRadio(toEarth chan []Message) *Radio {
    93.     r := &Radio{
    94.         fromRover: make(chan Message),
    95.     }
    96.     go r.run(toEarth)
    97.     return r
    98. }
    100. // run buffers messages sent by a rover until they
    101. // can be sent to Earth.
    102. func (r *Radio) run(toEarth chan []Message) {
    103.     var buffered []Message
    104.     for {
    105.         toEarth1 := toEarth
    106.         if len(buffered) == 0 {
    107.             toEarth1 = nil
    108.         }
    109.         select {
    110.         case m := <-r.fromRover:
    111.             buffered = append(buffered, m)
    112.         case toEarth1 <- buffered:
    113.             buffered = nil
    114.         }
    115.     }
    116. }
    118. // RoverDriver drives a rover around the surface of Mars.
    119. type RoverDriver struct {
    120.     commandc chan command
    121.     occupier *Occupier
    122.     name     string
    123.     radio    *Radio
    124. }
    126. // NewRoverDriver starts a new RoverDriver and returns it.
    127. func NewRoverDriver(
    128.     name string,
    129.     occupier *Occupier,
    130.     marsToEarth chan []Message,
    131. ) *RoverDriver {
    132.     r := &RoverDriver{
    133.         commandc: make(chan command),
    134.         occupier: occupier,
    135.         name:     name,
    136.         radio:    NewRadio(marsToEarth),
    137.     }
    138.     go r.drive()
    139.     return r
    140. }
    142. type command int
    144. const (
    145.     right command = 0
    146.     left  command = 1
    147. )
    149. // drive is responsible for driving the rover. It
    150. // is expected to be started in a goroutine.
    151. func (r *RoverDriver) drive() {
    152.     log.Printf("%s initial position %v", r.name, r.occupier.Pos())
    153.     direction := image.Point{X: 1, Y: 0}
    154.     updateInterval := 250 * time.Millisecond
    155.     nextMove := time.After(updateInterval)
    156.     for {
    157.         select {
    158.         case c := <-r.commandc:
    159.             switch c {
    160.             case right:
    161.                 direction = image.Point{
    162.                     X: -direction.Y,
    163.                     Y: direction.X,
    164.                 }
    165.             case left:
    166.                 direction = image.Point{
    167.                     X: direction.Y,
    168.                     Y: -direction.X,
    169.                 }
    170.             }
    171.             log.Printf("%s new direction %v", r.name, direction)
    172.         case <-nextMove:
    173.             nextMove = time.After(updateInterval)
    174.             newPos := r.occupier.Pos().Add(direction)
    175.             if r.occupier.MoveTo(newPos) {
    176.                 log.Printf("%s moved to %v", r.name, newPos)
    177.                 r.checkForLife()
    178.                 break
    179.             }
    180.             log.Printf("%s blocked trying to move from %v to %v", r.name, r.occupier.Pos(), newPos)
    181.             // Pick one of the other directions randomly.
    182.             // Next time round, we'll try to move in the new
    183.             // direction.
    184.             dir := rand.Intn(3) + 1
    185.             for i := 0; i < dir; i++ {
    186.                 direction = image.Point{
    187.                     X: -direction.Y,
    188.                     Y: direction.X,
    189.                 }
    190.             }
    191.             log.Printf("%s new random direction %v", r.name, direction)
    192.         }
    193.     }
    194. }
    196. func (r *RoverDriver) checkForLife() {
    197.     // Successfully moved to new position.
    198.     sensorData := r.occupier.Sense()
    199.     if sensorData.LifeSigns < 900 {
    200.         return
    201.     }
    202.     r.radio.SendToEarth(Message{
    203.         Pos:       r.occupier.Pos(),
    204.         LifeSigns: sensorData.LifeSigns,
    205.         Rover:     r.name,
    206.     })
    207. }
    209. // Left turns the rover left (90° counterclockwise).
    210. func (r *RoverDriver) Left() {
    211.     r.commandc <- left
    212. }
    214. // Right turns the rover right (90° clockwise).
    215. func (r *RoverDriver) Right() {
    216.     r.commandc <- right
    217. }
    219. // MarsGrid represents a grid of some of the surface
    220. // of Mars. It may be used concurrently by different
    221. // goroutines.
    222. type MarsGrid struct {
    223.     bounds image.Rectangle
    224.     mu     sync.Mutex
    225.     cells  [][]cell
    226. }
    228. // SensorData holds information about what's in
    229. // a point in the grid.
    230. type SensorData struct {
    231.     LifeSigns int
    232. }
    234. type cell struct {
    235.     groundData SensorData
    236.     occupier   *Occupier
    237. }
    239. // NewMarsGrid returns a new MarsGrid of the
    240. // given size.
    241. func NewMarsGrid(size image.Point) *MarsGrid {
    242.     grid := &MarsGrid{
    243.         bounds: image.Rectangle{
    244.             Max: size,
    245.         },
    246.         cells: make([][]cell, size.Y),
    247.     }
    248.     for y := range grid.cells {
    249.         grid.cells[y] = make([]cell, size.X)
    250.         for x := range grid.cells[y] {
    251.             cell := &grid.cells[y][x]
    252.             cell.groundData.LifeSigns = rand.Intn(1000)
    253.         }
    254.     }
    255.     return grid
    256. }
    258. // Size returns a Point representing the size of the grid.
    259. func (g *MarsGrid) Size() image.Point {
    260.     return g.bounds.Max
    261. }
    263. // Occupy occupies a cell at the given point in the grid. It
    264. // returns nil if the point is already occupied or the point is outside
    265. // the grid. Otherwise it returns a value that can be used
    266. // to move to different places on the grid.
    267. func (g *MarsGrid) Occupy(p image.Point) *Occupier {
    268.     g.mu.Lock()
    269.     defer g.mu.Unlock()
    270.     cell := g.cell(p)
    271.     if cell == nil || cell.occupier != nil {
    272.         return nil
    273.     }
    274.     cell.occupier = &Occupier{
    275.         grid: g,
    276.         pos:  p,
    277.     }
    278.     return cell.occupier
    279. }
    281. func (g *MarsGrid) cell(p image.Point) *cell {
    282.     if !p.In(g.bounds) {
    283.         return nil
    284.     }
    285.     return &g.cells[p.Y][p.X]
    286. }
    288. // Occupier represents an occupied cell in the grid.
    289. type Occupier struct {
    290.     grid *MarsGrid
    291.     pos  image.Point
    292. }
    294. // MoveTo moves the occupier to a different cell in the grid.
    295. // It reports whether the move was successful
    296. // It might fail because it was trying to move outside
    297. // the grid or because the cell it's trying to move into
    298. // is occupied. If it fails, the occupier remains in the same place.
    299. func (o *Occupier) MoveTo(p image.Point) bool {
    300.     o.grid.mu.Lock()
    301.     defer o.grid.mu.Unlock()
    302.     newCell := o.grid.cell(p)
    303.     if newCell == nil || newCell.occupier != nil {
    304.         return false
    305.     }
    306.     o.grid.cell(o.pos).occupier = nil
    307.     newCell.occupier = o
    308.     o.pos = p
    309.     return true
    310. }
    312. // Sense returns sensory data from the current cell.
    313. func (o *Occupier) Sense() SensorData {
    314.     o.grid.mu.Lock()
    315.     defer o.grid.mu.Unlock()
    316.     return o.grid.cell(o.pos).groundData
    317. }
    319. // Pos returns the current grid position of the occupier.
    320. func (o *Occupier) Pos() image.Point {
    321.     return o.pos
    322. }

    marsgrid.go

    1. package main
    3. import (
    4.     "image"
    5.     "sync"
    6. )
    8. func main() {
    9. }
    11. // MarsGrid represents a grid of some of the surface
    12. // of Mars. It may be used concurrently by different
    13. // goroutines.
    14. type MarsGrid struct {
    15.     bounds image.Rectangle
    16.     mu     sync.Mutex
    17.     cells  [][]cell
    18. }
    20. // cell holds information about a given cell in
    21. // the grid.
    22. type cell struct {
    23.     occupier *Occupier
    24. }
    26. // NewMarsGrid returns a new MarsGrid of the
    27. // given size.
    28. func NewMarsGrid(size image.Point) *MarsGrid {
    29.     grid := &MarsGrid{
    30.         bounds: image.Rectangle{
    31.             Max: size,
    32.         },
    33.         cells: make([][]cell, size.Y),
    34.     }
    35.     for i := range grid.cells {
    36.         grid.cells[i] = make([]cell, size.X)
    37.     }
    38.     return grid
    39. }
    41. // Size returns the size of the grid.
    42. func (g *MarsGrid) Size() image.Point {
    43.     return g.bounds.Max
    44. }
    46. // Occupy occupies a cell at the given point in the grid. It
    47. // returns nil if the point is already or the point is outside
    48. // the grid. Otherwise it returns a value that can be used
    49. // to move to different places on the grid.
    50. func (g *MarsGrid) Occupy(p image.Point) *Occupier {
    51.     g.mu.Lock()
    52.     defer g.mu.Unlock()
    53.     cell := g.cell(p)
    54.     if cell == nil || cell.occupier != nil {
    55.         return nil
    56.     }
    57.     cell.occupier = &Occupier{
    58.         grid: g,
    59.         pos:  p,
    60.     }
    61.     return cell.occupier
    62. }
    64. // cell returns a pointer to the cell at the
    65. // given position, or nil if it's outside
    66. // the grid.
    67. func (g *MarsGrid) cell(p image.Point) *cell {
    68.     if !p.In(g.bounds) {
    69.         return nil
    70.     }
    71.     return &g.cells[p.Y][p.X]
    72. }
    74. // Occupier represents an occupied cell in the grid.
    75. type Occupier struct {
    76.     grid *MarsGrid
    77.     pos  image.Point
    78. }
    80. // MoveTo moves the occupier to a different cell in the grid.
    81. // It reports whether the move was successful
    82. // It might fail because it was trying to move outside
    83. // the grid or because the cell it's trying to move into
    84. // is occupied. If it fails, the occupier remains in the same place.
    85. func (o *Occupier) MoveTo(p image.Point) bool {
    86.     o.grid.mu.Lock()
    87.     defer o.grid.mu.Unlock()
    88.     newCell := o.grid.cell(p)
    89.     if newCell == nil || newCell.occupier != nil {
    90.         return false
    91.     }
    92.     o.grid.cell(o.pos).occupier = nil
    93.     newCell.occupier = o
    94.     o.pos = p
    95.     return true
    96. }
    98. // Pos returns the current grid position of the occupier.
    99. func (o *Occupier) Pos() image.Point {
    100.     return o.pos
    101. }