第1章 关于Go语言的介绍 (已看)

　　1.1 用Go解决现代编程难题

　　　　1.1.1 开发速度

　　　　1.1.2 并发

　　　　　　1. goroutine

　　　　　　2. 通道

　　　　1.1.3 Go语言的类型系统

　　　　　　1. 类型简单

　　　　　　2. Go接口对一组行为建模

　　　　1.1.4 内存管理

　　1.2 你好,Go

　　　　介绍Go playground

第2章 快速开始一个Go程序

　　2.1 程序架构

　　2.2 main包

　　2.3 search包

　　　　2.3.1 search.go

　　　　2.3.2 feed.go

　　　　2.3.3 match.go/default.go

　　2.4 RSS匹配器

　　2.5 小结

第3章 打包和工具链 (已看)

　　3.1 包

　　　　3.1.1 包名惯例

　　　　3.1.2 main包

　　3.2 导入

　　　　3.2.1 远程导入

　　　　3.2.2 命名导入

　　3.3 函数init

　　3.4 使用Go的工具

  1. package main
  2.  
  3. import (
  4.     "fmt"
  5.     "chapter3/words"
  6.     "io/ioutil"
  7.     "os"
  8. )
  9.  
  10. func main() {
  11.     filename := os.Args[]
  12.  
  13.     contents,err := ioutil.ReadFile(filename)
  14.  
  15.     if err != nil {
  16.         fmt.Println(err)
  17.         return
  18.     }
  19.  
  20.     text := string(contents)
  21.  
  22.     count := words.CountWords(text)
  23.     fmt.Printf("There are %d word in your text. \n",count)
  24. }

　　3.5 进一步介绍Go开发工具

　　　　3.5.1 go vet

　　　　3.5.2 Go代码格式化

　　　　3.5.3 Go语言的文档

　　　　　　1. 从命令行获取文档

　　　　　　2. 浏览文档

　　3.6 与其他Go开发者合作

　　　　以分享为目的创建代码库

　　　　　　1. 包应该在代码库的根目录中

　　　　　　2. 包可以非常小

　　　　　　3. 对代码执行go fmt

　　　　　　4. 给代码写文档

　　3.7 依赖管理

　　　　3.7.1 第三方依赖

　　　　3.7.2 对gb的介绍

　　3.8 小结

第4章 数组,切片和映射 (已看)

　　4.1 数组的内部实现和基础功能

  1. ]int
  2.  
  3. array := [],,,,}
  4.  
  5. array := [...],,,,}
  6.  
  7. array := []:,:}
  8.  
  9. array := []{,,,,}
  10. array[] = 
  11.  
  12. array := []*::new(int)}
  13. *array[] =
  14. *array[] = 
  15.  
  16. ]string
  17. array2 := []string{"Red","Blue","Green","Yellow","Pink"}
  18. array1 = array2
  19.  
  20. ]string
  21. array2 := []string{"Red","Blue","Green","Yellow","Pink"}
  22. array1 = array2
  23. Compiler Error:
  24. cannot use array2 (type []]string in assignment
  25.  
  26. ]*string
  27. array2 := []*string{new(string),new(string),new(string)}
  28. *array2[] = "Red"
  29. *array2[] = "Blue"
  30. *array2[] = "Green"
  31. array1 = array2
  32.  
  33. ][]int
  34. array := [][],},{,},{,},{,}}
  35. array := [][]:{,},:{,}}
  36. array := [][]:{:},{:}}
  37.  
  38. ][]int
  39. array[][] =
  40. array[][] =
  41. array[][] =
  42. array[][] = 
  43.  
  44. ][]int
  45. ][]int
  46. array2[][] =
  47. array2[][] =
  48. array2[][] =
  49. array2[][] =
  50. array1 = array2
  51. ]]
  52. ][]
  53.  
  54. var array [1e6]int
  55. foo(array)
  56. func foo(array [1e6]int) {
  57.     ...
  58. }
  59.  
  60. var array [1e6]int
  61. foo(&array)
  62. func foo(array *[1e6]int) {
  63.     ...
  64. }

　　　　4.1.1 内部实现

　　　　4.1.2 声明和初始化

　　　　4.1.3 使用数组

　　　　4.1.4 多维数组

　　　　4.1.5 在函数间传递数组

　　4.2 切片的内部实现和基础功能

  1. slice := make([])
  2.  
  3. slice := make([],)
  4.  
  5. slice := make([],)
  6. Compiler Error:
  7. len larger than cap in make([]int)
  8.  
  9. slice := []string{"Red","Blue","Green","Yellow","Pink"}
  10. slice := [],,}
  11.  
  12. slice := []:""}
  13.  
  14. array := [],,}
  15. slice := [],,}
  16.  
  17. var slice []int    // 创建nil整型切片
  18.  
  19. slice := make([])
  20. slice := []int{}
  21.  
  22. slice := [],,,,}
  23. slice[] = 
  24.  
  25. slice := [],,,,}
  26. newSlice := slice[:]
  27. newSLice[] = 
  28.  
  29. slice := [],,,,}
  30. newSlice := slice[:]
  31. newSlice[] =
  32. Runtime Exception:
  33. panic: runtime error: index out of range
  34.  
  35. slice := [],,,,}
  36. newSlice := slice[:]
  37. newSlice = append(newSlice,)
  38.  
  39. slice := [],,,}
  40. newSlice := append(slice,)
  41.  
  42. souce := []string{"Apple","Orange","Plum","Banana","Grape"}
  43. slice := source[::]
  44. slice := source[::]
  45.  
  46. Runtime Error:
  47. panic: runtime error: slice bounds out of range
  48.  
  49. s1 := [],}
  50. s2 := [],}
  51. fmt.Printf("%v\n",append(s1,s2...))
  52.  
  53. Output:
  54. [   ]
  55.  
  56. slice := [],,,}
  57. for index,value := range slice {
  58.     fmt.Printf("Index: %d value: %d\n",index,value)
  59. }
  60.  
  61. Output:
  62. Index:  Value:
  63. Index:  Value:
  64. Index:  Value:
  65. Index:  Value: 
  66.  
  67. slice := [],,,}
  68. for index,value := range slice {
  69.     fmt.Printf("Value: %d Value-Addr: %X ElementAddr: %X\n", value,&value,&slice[index])
  70. }
  71.  
  72. Output:
  73. Value:  Value-Addr:  ElemAddr: 1052E100
  74. Value:  Value-Addr:  ElemAddr: 1052E104
  75.  
  76. slice := [],,,}
  77. ;index < len(slice);index++ {
  78.     fmt.Printf("Index: %d Value:%d\n",index,slice[index])
  79. }
  80.  
  81. slice := [][]},{,}}
  82.  
  83. slice := [][]},{,}}
  84. slice[] = append(slice[],)
  85.  
  86. slice := make([]int,1e6)
  87. slice = foo(slice)
  88. func foo(slice []int) []int {
  89.     ...
  90.     return slice
  91. }

　　　　4.2.1 内部实现

　　　　4.2.2 创建和初始化

　　　　　　1. make和切片字面量

　　　　　　2. nil和空切片

　　　　4.2.3 使用切片

　　　　　　1. 赋值和切片

　　　　　　2. 切片增长

　　　　　　3. 创建切片时的3个索引

　　　　　　4. 迭代切片

　　　　4.2.4 多维切片

　　　　4.25 在函数间传递切片

　　4.3 映射的内部实现和基础功能

  1. dict := make(map[string]int)
  2. dict := map[string]string{"Red":"#da1137","Orange":"#e95a22"}
  3.  
  4. dict := map[[]string]int{}
  5. Compiler Exception:
  6. invalid map key type []string
  7.  
  8. dict := map[int][]sting{}
  9.  
  10. colors := map[string]string{}
  11. colors["Red"] = "#da1337"
  12.  
  13. var colors map[string]string
  14.  
  15. colors["Red"] = "#da1337"
  16.  
  17. Runtime Error:
  18. panic: runtime error: assignment to entry in nil map
  19.  
  20. value,exsits := colors["Blue"]
  21. if exists {
  22.     fmt.Println(value)
  23. }
  24.  
  25. value := colors["Blue"]
  26. if value != "" {
  27.     fmt.Println(value)
  28. }
  29.  
  30. colors := map[string]string{
  31.     "AliceBlue": "#f0f8ff",
  32.     "Coral":     "#ff7F50",
  33.     "DarkGray":     "#a9a9a9",
  34.     "ForestGreen":"#228b22",
  35. }
  36.  
  37. for key,value := range colors {
  38.     fmt.Printf("Key: %s Value: %s\n",key,value)
  39. }
  40.  
  41. delete(colors,"Coral")
  42. for key,value := range colors {
  43.     fmt.Printf("Key: %s Value: %s\n",key,value)
  44. }
  45.  
  46. func main() {
  47.     colors: = map[string]string {
  48.         "AliceBlue": "#f0f8ff",
  49.         "Coral": "#ff7F50",
  50.         "DarkGray": "#a9a9a9",
  51.         "ForestGreen": "#228b22",
  52.     }
  53.  
  54.     for key,value := range colors {
  55.         fmt.Printf("Key: %s Value: %s\n",key,value)
  56.     }
  57.  
  58.     removeColor(colors,"Coral")
  59.  
  60.     for key,value := range colors {
  61.         fmt.Printf("Key: %s Value: %s\n",key,value)
  62.     }
  63. }
  64.  
  65. func removeColor(colors map[string]string,key string) {
  66.     delete(colors,key)
  67. }

　　　　4.3.1 内部实现

　　　　4.3.2 创建和初始化

　　　　4.3.3 使用映射

　　　　4.3.4 在函数间传递映射

　　4.4 小结

第5章 Go语言的类型系统 (已看)

　　5.1 用户定义的类型

  1. type user struct {
  2.     name string
  3.     email string
  4.     ext int
  5.     privileged bool
  6. }
  7.  
  8. var bill user
  9.  
  10. lisa := user{
  11.     name: "Lisa",
  12.     email: "lisa@email.com",
  13.     ext:,
  14.     privileged:true,
  15. }
  16.  
  17. user{
  18.     name: "Lisa",
  19.     email:"lisa@email.com",
  20.     ext:,
  21.     priviledged:true,
  22. }
  23.  
  24. lisa := user{,true}
  25.  
  26. type admin struct {
  27.     person user
  28.     level string
  29. }
  30.  
  31. fred := admin{
  32.     person:user {
  33.         name: "Lisa",
  34.         email: "lisa@email.com",
  35.         ext: ,
  36.         priviledged:true,
  37.     },
  38.     level:"super",
  39. }
  40.  
  41. type Duration int64
  42.  
  43. package main
  44.  
  45. type Duration int64
  46.  
  47. func main() {
  48.     var dur Duration
  49.     dur = int64()
  50. }
  51.  
  52. cannot use int64() (type in64) as type Duration in assignment

　　5.2 方法

  1. package main
  2.  
  3. import (
  4.     "fmt"
  5. )
  6.  
  7. type user struct {
  8.     name string
  9.     email string
  10. }
  11.  
  12. func (u user) notify() {
  13.     fmt.Printf("Sending User Email To %s<%s>\n",u.name,u.email)
  14. }
  15.  
  16. func (u *user) changeEmail(email string) {
  17.     u.email = email
  18. }
  19.  
  20. func main() {
  21.     // user类型的值可以用来调用使用值接收者声明的方法
  22.     bill := user{"Bill","bill@email.com"}
  23.     bill.notify()
  24.     // 指向user类型值的指针也可以用来调用使用值接收者声明的方法
  25.     lisa := &user{"Lisa","lisa@email.com"}
  26.     lisa.notify()
  27.     （*lisa).notify()
  28.     // user类型的值可以用来调用使用指针接收者声明的方法
  29.     bill.changeEmail("bill@newdomain.com")
  30.     (&bill).changeEmail("bill@newdomain.com")
  31.     bill.notify()
  32.     // 指向user类型值的指针可以用来调用使用指针接收者声明的方法
  33.     lisa.changeEmail("lisa@newdomain.com")
  34.     lisa.notify()
  35. }

　　5.3 类型的本质

  1. type Time struct {
  2.     sec int64
  3.     nsec int32
  4.     loc *Location
  5. }
  6.  
  7. func Now() Time {
  8.     sec,nsec := now()
  9.     return Time{sec + unixToInternal,nsec,Local}
  10. }
  11.  
  12. func (t Time) Add(d Duration) Time {
  13.     t.sec += int64(d/1e9)
  14.     nsec := int32(t.nsec) + int32(d%1e9)
  15.     if nesc >= 1e9 {
  16.         t.sec++
  17.         nsec -= 1e9
  18.     }  {
  19.         t.sec--
  20.         nsec += 1e9
  21.     }
  22.     t.nsec = nsec
  23.     return t
  24. }
  25.  
  26. type File struct {
  27.     *file
  28. }
  29.  
  30. type file struct {
  31.     fd int
  32.     name string
  33.     dirinfo *dirInfo
  34.     nepipe int32
  35. }
  36.  
  37. func Open(name string) (file *File,err error) {
  38.     )
  39. }
  40.  
  41. func (f *File) Chdir() error {
  42.     if f == nil {
  43.         return ErrInvalid
  44.     }
  45.     if e := syscall.Fchdir(f.fd); e != nil {
  46.         return &PathError{"chdir",f.name,e}
  47.     }
  48.     return nil
  49. }

　　　　5.3.1 内置类型

　　　　5.3.2 引用类型

　　　　5.3.3 结构类型

　　5.4 接口

  1. package main
  2.  
  3. import (
  4.     "fmt"
  5.     "io"
  6.     "net/http"
  7.     "os"
  8. )
  9.  
  10. func init() {
  11.      {
  12.         fmt.Println("Usage: ./example2 <url>")
  13.         os.Exit(-)
  14.     }
  15. }
  16.  
  17. func main() {
  18.     r,err := http.Get(os.Args[])
  19.     if err != nil {
  20.         fmt.Println(err)
  21.         return
  22.     }
  23.  
  24.     io.Copy(os.Stdout,r.Body)
  25.     if err := r.Body.Close(); err != nil {
  26.         fmt.Println(err)
  27.     }
  28. }
  29.  
  30. package main
  31.  
  32. import (
  33.     "bytes"
  34.     "fmt"
  35.     "io"
  36.     "os"
  37. )
  38.  
  39. func main() {
  40.     var b bytes.Buffer
  41.     b.Write([]byte("Hello"))
  42.     fmt.Fprintf(&b,"World!")
  43.     io.Copy(os.Stdout,&b)
  44. }
  45.  
  46. package main
  47.  
  48. import (
  49.     "fmt"
  50. )
  51.  
  52. type notifier interface {
  53.     notify()
  54. }
  55.  
  56. type user struct {
  57.     name string
  58.     email string
  59. }
  60.  
  61. func (u *user) notify() {
  62.     fmt.Printf("Sending user email to %s<%s>\n",u.name,u.email)
  63. }
  64.  
  65. func main() {
  66.     u := user{"Bill","bill@email.com"}
  67.  
  68.     sendNotification(&u)
  69. }
  70.  
  71. func sendNotification(n notifier) {
  72.     n.notify()
  73. }
  74.  
  75. package main
  76.  
  77. import (
  78.     "fmt"
  79. )
  80.  
  81. type notifier interface {
  82.     notify()
  83. }
  84.  
  85. type user struct {
  86.     name string
  87.     email string
  88. }
  89.  
  90. func (u *user) notify() {
  91.     fmt.Printf("Sending user email to %s<%s>\n",u.name,u.email)
  92. }
  93.  
  94. type admin struct {
  95.     name string
  96.     email string
  97. }
  98.  
  99. func (a *admin) notify() {
  100.     fmt.Printf("Sending admin email to %s<%s>\n",a.name,a.email)
  101. }
  102.  
  103. func main () {
  104.     bil := user{"Bill","bill@email.com"}
  105.     sendNotification(&bill)
  106.  
  107.     lisa := admin{"Lisa","lisa@email.com"}
  108.     sendNotification(&lisa)
  109. }
  110.  
  111. func sendNotification(n notifier) {
  112.     n.notify()
  113. }

　　　　5.4.1 标准库

　　　　5.4.2 实现

　　　　5.4.3 方法集

　　　　5.4.4 多态

　　5.5 嵌入类型

  1. package main
  2.  
  3. import (
  4.     "fmt"
  5. )
  6.  
  7. type user struct {
  8.     name string
  9.     email string
  10. }
  11.  
  12. func (u *user) notify() {
  13.     fmt.Printf("Sending user email to %s<%s>\n",u.name,u.email)
  14. }
  15.  
  16. type admin struct {
  17.     user
  18.     level string
  19. }
  20.  
  21. func main() {
  22.     ad := admin {
  23.         user: user{
  24.             name: "john smith",
  25.             email: "john@yahoo.com",
  26.         },
  27.         level: "super"
  28.     }
  29.  
  30.     ad.user.notify()
  31.  
  32.     ad.notify()
  33. }
  34.  
  35. package main
  36.  
  37. import (
  38.     "fmt"
  39. )
  40.  
  41. type notifier interface {
  42.     notify()
  43. }
  44.  
  45. type user struct {
  46.     name string
  47.     email string
  48. }
  49.  
  50. func (u *user) notify() {
  51.     fmt.Printf("Sending user email to %s<%s>\n",u.name,u.email)
  52. }
  53.  
  54. type admin struct {
  55.     user
  56.     level string
  57. }
  58.  
  59. func main() {
  60.     ad := admin{
  61.         user: user{
  62.             name: "john smith",
  63.             email: "john@yahoo.com",
  64.         },
  65.         level: "super",
  66.     }
  67.  
  68.     sendNotification(&ad)
  69. }
  70.  
  71. func sendNotification(n notifier) {
  72.     n.notify()
  73. }

　　5.6 公开或未公开的标识符

　　5.7 小结

第6章 并发

　　6.1 并发与并行

　　6.2 goroutine

  1. package main
  2.  
  3. import (
  4.     "runtime"
  5.     "sync"
  6.     "fmt"
  7. )
  8.  
  9. func main() {
  10.     runtime.GOMAXPROCS()
  11.  
  12.     var wg sync.WaitGroup
  13.     wg.Add()
  14.  
  15.     fmt.Println("Start Gorountines")
  16.  
  17.     go func() {
  18.         defer wg.Done()
  19.  
  20.         ; count < ; count++ {
  21.             ; char++ {
  22.                 fmt.Printf("%c ",char)
  23.             }
  24.         }
  25.     }()
  26.  
  27.     go func() {
  28.         defer wg.Done()
  29.  
  30.         ; count < ; count++ {
  31.             ; char++ {
  32.                 fmt.Printf("%c ",char)
  33.             }
  34.         }
  35.     }()
  36.  
  37.     fmt.Println("Waiting To Finish")
  38.     wg.Wait()
  39.  
  40.     fmt.Println("\nTerminating Program")
  41. }
  42.  
  43. package main
  44.  
  45. import (
  46.     "sync"
  47.     "runtime"
  48.     "fmt"
  49. )
  50.  
  51. var wg sync.WaitGroup
  52.  
  53. func main() {
  54.     runtime.GOMAXPROCS(runtime.NumCPU())
  55.     wg.Add()
  56.  
  57.     fmt.Println("Create Goroutines")
  58.     go printPrime("A")
  59.     go printPrime("B")
  60.  
  61.     fmt.Println("Waiting To Finish")
  62.     wg.Wait()
  63.  
  64.     fmt.Println("Terminating Program")
  65. }
  66.  
  67. func printPrime(prefix string) {
  68.     defer wg.Done()
  69.  
  70.     next:
  71.         ; outer < ; outer++ {
  72.             ; inner < outer; inner++ {
  73.                  {
  74.                     continue next
  75.                 }
  76.             }
  77.             fmt.Printf("%s:%d\n",prefix,outer)
  78.         }
  79.         fmt.Println("Completed",prefix)
  80. }

　　6.3 竞争状态

  1. // 这个示例程序展示如何在程序里造成竞争状态
  2. // 实际上不希望出现这种情况
  3.  
  4. package main
  5.  
  6. import (
  7.     "sync"
  8.     "runtime"
  9.     "fmt"
  10. )
  11.  
  12. var (
  13.     counter int
  14.     wg sync.WaitGroup
  15. )
  16.  
  17. func main() {
  18.     wg.Add()
  19.  
  20.     go incCounter()
  21.     go incCounter()
  22.  
  23.     wg.Wait()
  24.  
  25.     fmt.Println("Final Counter:",counter)
  26. }
  27.  
  28. func incCounter(id int) {
  29.     defer wg.Done()
  30.  
  31.     ; count < ; count++ {
  32.         value := counter
  33.  
  34.         runtime.Gosched()
  35.  
  36.         value++
  37.  
  38.         counter = value
  39.     }
  40. }

　　6.4 锁住共享资源

　　　　6.4.1 原子函数

  1. package main
  2.  
  3. import (
  4.     "sync"
  5.     "fmt"
  6.     "time"
  7.     "sync/atomic"
  8. )
  9.  
  10. var (
  11.     shutdown int64
  12.     wg sync.WaitGroup
  13. )
  14.  
  15. func main() {
  16.     wg.Add()
  17.  
  18.     go doWork("A")
  19.     go doWork("B")
  20.  
  21.     time.Sleep( * time.Second)
  22.  
  23.     fmt.Println("Shutdown Now")
  24.     atomic.StoreInt64(&shutdown,)
  25.  
  26.     wg.Wait()
  27. }
  28.  
  29. func doWork(name string) {
  30.     defer wg.Done()
  31.  
  32.     for {
  33.         fmt.Printf("Doing %s Work\n",name)
  34.         time.Sleep( * time.Millisecond)
  35.  
  36.          {
  37.             fmt.Printf("Shutting %s Down\n",name)
  38.             break
  39.         }
  40.     }
  41. }

　　　　6.4.2 互斥锁

  1. package main
  2.  
  3. import (
  4.     "sync"
  5.     "runtime"
  6.     "fmt"
  7. )
  8.  
  9. var (
  10.     counter int
  11.     wg sync.WaitGroup
  12.     mutex sync.Mutex
  13. )
  14.  
  15. func main() {
  16.     wg.Add()
  17.  
  18.     go incCounter()
  19.     go incCounter()
  20.  
  21.     wg.Wait()
  22.     fmt.Printf("Final Counter: %d\n",counter)
  23. }
  24.  
  25. func incCounter(id int) {
  26.     defer wg.Done()
  27.  
  28.     ; count < ; count++ {
  29.         mutex.Lock()
  30.         {
  31.             value := counter
  32.             runtime.Gosched()
  33.             value++
  34.             counter = value
  35.         }
  36.         mutex.Unlock()
  37.     }
  38. }

　　6.5 通道

　　　　6.5.1 无缓冲的通道

  1. package main
  2.  
  3. import (
  4.     "sync"
  5.     "fmt"
  6.     "math/rand"
  7.     "time"
  8. )
  9.  
  10. var wg sync.WaitGroup
  11.  
  12. func init() {
  13.     rand.Seed(time.Now().UnixNano())
  14. }
  15.  
  16. func main() {
  17.     court := make(chan int)
  18.  
  19.     wg.Add()
  20.  
  21.     go player("Nadal",court)
  22.     go player("Djokovic",court)
  23.  
  24.     court <- 
  25.  
  26.     wg.Wait()
  27. }
  28.  
  29. func player(name string,court chan int) {
  30.     defer wg.Done()
  31.  
  32.     for {
  33.         ball,ok := <-court
  34.  
  35.         if !ok {
  36.             fmt.Printf("Player %s Won\n",name)
  37.         }
  38.  
  39.         n := rand.Intn()
  40.          ==  {
  41.             fmt.Printf("number=%s Player %s Missed\n",n,name)
  42.             close(court)
  43.             return
  44.         }
  45.  
  46.         fmt.Printf("Player %s Hit %d\n",name,ball)
  47.         ball++
  48.  
  49.         court <- ball
  50.     }
  51. }
  52.  
  53. package main
  54.  
  55. import (
  56.     "sync"
  57.     "fmt"
  58.     "time"
  59. )
  60.  
  61. var wg sync.WaitGroup
  62.  
  63. func main() {
  64.     baton := make(chan int)
  65.     wg.Add()
  66.  
  67.     go Runner(baton)
  68.  
  69.     baton<-
  70.     wg.Wait()
  71. }
  72.  
  73. func Runner(baton chan int) {
  74.     var newRunner int
  75.  
  76.     runner := <-baton
  77.     fmt.Printf("Runner %d Running With Baton\n",runner)
  78.      {
  79.         newRunner = runner +
  80.         fmt.Printf("Runner %d To The Line\n",newRunner)
  81.         go Runner(baton)
  82.     }
  83.  
  84.     time.Sleep( * time.Millisecond)
  85.  
  86.      {
  87.         fmt.Printf("Runner %d Finished,Race Over\n",runner)
  88.         wg.Done()
  89.         return
  90.     }
  91.  
  92.     fmt.Printf("Runner %d Exchange With Runner %d\n",runner,newRunner)
  93.  
  94.     baton <-newRunner
  95. }

　　　　6.5.2 有缓冲的通道

  1. package main
  2.  
  3. import (
  4.     "sync"
  5.     "math/rand"
  6.     "time"
  7.     "fmt"
  8. )
  9.  
  10. const (
  11.     numberGoroutines =
  12.     taskLoad =
  13. )
  14.  
  15. var wg sync.WaitGroup
  16.  
  17. func int() {
  18.     rand.Seed(time.Now().Unix())
  19. }
  20.  
  21. func main() {
  22.     tasks := make(chan string,taskLoad)
  23.  
  24.     wg.Add(numberGoroutines)
  25.     ; gr <= numberGoroutines; gr++ {
  26.         go worker(tasks,int64(gr))
  27.     }
  28.  
  29.     ; post <= taskLoad; post++ {
  30.         tasks <- fmt.Sprintf("Task: %d",post)
  31.     }
  32.  
  33.     close(tasks)
  34.  
  35.     wg.Wait()
  36. }
  37.  
  38. func worker(tasks chan string,worker int64){
  39.     defer wg.Done()
  40.  
  41.     for {
  42.         task,ok := <-tasks
  43.         if !ok {
  44.             fmt.Printf("Worker: %d : Shutting Down\n",worker)
  45.             return
  46.         }
  47.  
  48.         fmt.Printf("Worker: %d : Started %s\n",worker,task)
  49.  
  50.         sleep := rand.Int63n()
  51.         time.Sleep(time.Duration(sleep) * time.Millisecond)
  52.  
  53.         fmt.Print("Worker: %d : Completed %s\n",worker,task)
  54.     }
  55. }

第7章 并发模式

　　7.1 runner

　　7.2 pool

　　7.3 work

　　7.4 小结

第8章 标准库

　　8.1 文档与源代码

　　8.2 记录日志

　　　　8.2.1 log包

　　　　8.2.2 定制的日志记录器

　　　　8.2.3 结论

　　8.3 编码/解码

　　　　8.3.1 解码JSON

　　　　8.3.2 编码JSON

　　　　8.3.3 结论

　　8.4 输入和输出

　　　　8.4.1 Writer和Reader接口

　　　　8.4.2 整合并完成工作

　　　　8.4.3 简单的curl

　　　　8.4.4 结论

　　8.5 小结

第9章 测试和性能

　　9.1 单元测试

　　　　9.1.1 基础单元测试

　　　　9.1.2 表组测试

　　　　9.1.3 模仿调用

　　　　9.1.4 测试服务端点

　　9.2 示例

　　9.3 基准测试

　　9.4 小结

Go语言实战 (William,Kennedy 等著)的更多相关文章

  1. 《Go语言实战》书摘

    书籍简介 名称:Go语言实战 作者: 威廉·肯尼迪 (William Kennedy) / 布赖恩·克特森 (Brian Ketelsen) / 埃里克·圣马丁 (Erik St.Martin) 内容 ...

  2. R入门<三>-R语言实战第4章基本数据管理摘要

    入门书籍:R语言实战 进度:1-4章 摘要: 1)实用的包 forecast:用于做时间序列预测的,有auto.arima函数 RODBC:可以用来读取excel文件.但据说R对csv格式适应更加良好 ...

  3. R语言实战（三）基本图形与基本统计分析

    本文对应<R语言实战>第6章:基本图形:第7章:基本统计分析 =============================================================== ...

  4. R语言实战（二）数据管理

    本文对应<R语言实战>第4章:基本数据管理:第5章:高级数据管理 创建新变量 #建议采用transform()函数 mydata <- transform(mydata, sumx ...

  5. R语言实战（一）介绍、数据集与图形初阶

    本文对应<R语言实战>前3章,因为里面大部分内容已经比较熟悉,所以在这里只是起一个索引的作用. 第1章       R语言介绍 获取帮助函数 help(), ? 查看函数帮助 exampl ...

  6. Swift语言实战晋级

    Swift语言实战晋级基本信息作者: 老镇 丛书名: 爱上Swift出版社:人民邮电出版社ISBN:9787115378804上架时间:2014-12-26出版日期:2015 年1月开本:16开页码: ...

  7. swift语言实战晋级-第9章 游戏实战-跑酷熊猫-9-10 移除平台与视差滚动

    9.9 移除场景之外的平台 用为平台是源源不断的产生的,如果不注意销毁,平台就将越积越多,虽然在游戏场景中看不到.几十个还看不出问题,那几万个呢?几百万个呢? 所以我们来看看怎么移除平台,那什么样的平 ...

  8. swift语言实战晋级-第9章 游戏实战-跑酷熊猫-7-8 移动平台的算法

    在上个小节,我们完成了平台的产生.那么我们来实现一下让平台移动.平台的移动,我们只需要在平台工厂类中写好移动的方法,然后在GameScene类中统一控制就行了. 在GameScene类中,有个upda ...

  9. Swift语言实战晋级-第9章 游戏实战-跑酷熊猫-5-6 踩踏平台是怎么炼成的

    在游戏中,有很多分来飞去的平台,这个平台长短不一.如果每种长度都去创建一张图片那是比较繁琐的事情.实际上,我们只用到3张图.分别是平台的,平台的中间部分,平台的右边.关键是平台的中间部分,两张中间部分 ...

随机推荐

  1. SQL-27 给出每个员工每年薪水涨幅超过5000的员工编号emp_no、薪水变更开始日期from_date以及薪水涨幅值salary_growth，并按照salary_growth逆序排列。 提示：在sqlite中获取datetime时间对应的年份函数为strftime('%Y', to_date)

    题目描述 给出每个员工每年薪水涨幅超过5000的员工编号emp_no.薪水变更开始日期from_date以及薪水涨幅值salary_growth,并按照salary_growth逆序排列. 提示:在s ...

  2. GTX使用（更新中）

    1.XILINX GTX介绍GTX是Virtex系列 FPGA上的低功耗吉比特收发器,在V6芯片上GTX工作带宽范围是750Mb/s到6.6Gb/s,支持收发双向,且收发双向独立.GTX接收和发送方向 ...

  3. CentOS7安装cratedb

    crate: 下载: https://crate.io/download/thank-you/?download=tar crash: 下载: https://crate.io/docs/client ...

  4. AngularJS2.0教程（一）快速上手之基础知识

    Why Angular2 Angular1.x显然非常成功,那么,为什么要剧烈地转向Angular2? 性能的限制 AngularJS当初是提供给设计人员用来快速构建HTML表单的一个内部工具.随着时 ...

  5. java 移动开发获取多级下拉框json数据的类和mobile-select-area插件

    我这里以行政区划做例子 //这个类是把数据库中的行政区划转化为json格式的data @SuppressWarnings("rawtypes")public class XzqhL ...

  6. AssetBundle自动标签、打包

    using System;using System.Collections.Generic;using System.IO;using UnityEditor;using UnityEngine; / ...

  7. Mybaties学习

    基于现在Mybatis 我没有学习太多,就基于简单的增删改查进行基础学习. 学习资源来自    http://www.cnblogs.com/xdp-gacl/p/4261895.html 1  引入 ...

  8. dict的items（）方法于iteritems（）方法的不同

    items方法将所有的字典以列表方式返回,其中项在返回时没有特殊的顺序: iteritems方法有相似的作用,但是返回一个迭代器对象.

  9. 爬虫系列2：scrapy项目入门案例分析

    本文从一个基础案例入手,较为详细的分析了scrapy项目的建设过程(在官方文档的基础上做了调整).主要内容如下: 0.准备工作 1.scrapy项目结构 2.编写spider 3.编写item.py ...

  10. mysql取差集、交集、并集

    mysql取差集.交集.并集 博客分类: Mysql数据库 需求:从两个不同的结果集(一个是子集,一个是父集),字段为电话号码phone_number,找出父集中缺少的电话号码,以明确用户身份. 结合 ...