7.Go编程快速入门学习

func demo1() {
  type person struct {
    Id   int    `json:"id"`
    Name string `json:"name"`
  }
  var p person
  strJson := `{"id": 1024,"name": "WeiyiGeek"}`

  // 1.反序列化将JSON字符串绑定到对象对应属性之中.(他为何可以根据JSON字符串对应的key解析到对象属性之中)
  json.Unmarshal([]byte(strJson), &p)
  // 2.输出对象属性值进行验证
  fmt.Println("Id = ", p.Id, ",Name = ", p.Name)
}

// # 调用执行结果
Id =  1024 ,Name =  WeiyiGeek

type Kind uint
const (
  Invalid Kind = iota  // 非法类型
  Bool                 // 布尔型
  Int                  // 有符号整型
  Int8                 // 有符号8位整型
  Int16                // 有符号16位整型
  Int32                // 有符号32位整型
  Int64                // 有符号64位整型
  Uint                 // 无符号整型
  Uint8                // 无符号8位整型
  Uint16               // 无符号16位整型
  Uint32               // 无符号32位整型
  Uint64               // 无符号64位整型
  Uintptr              // 指针
  Float32              // 单精度浮点数
  Float64              // 双精度浮点数
  Complex64            // 64位复数类型
  Complex128           // 128位复数类型
  Array                // 数组
  Chan                 // 通道
  Func                 // 函数
  Interface            // 接口
  Map                  // 映射
  Ptr                  // 指针
  Slice                // 切片
  String               // 字符串
  Struct               // 结构体
  UnsafePointer        // 底层指针
)

type myInt int

func reflectType(x interface{}) {
  v := reflect.TypeOf(x)
  k := v.Kind()   // 获取的是反射对象的类型 (注意与下面 reflect.ValueOf(x).Kind() 的区别)
  fmt.Printf("Reflect Type = %v, Name Type : %v,Kind : %s (%d)\n", v, v.Name(), k, k)  
}

func demo1() {
  var a int64 = 100    // 整形
  var b float32 = 3.14 // 浮点型
  var c rune           // 类型别名
  var d myInt = 1024   // 自定义类型
  type person struct { // 结构体
    name string
    age  int
  }
  type book struct{ title string }
  var e = person{
    name: "WeiyiGeek",
    age:  18,
  }
  var f = book{title: "《跟WeiyiGeek学Go语言》"}

  // 调用查看反射类型
  reflectType(a)
  reflectType(b)
  reflectType(c)
  reflectType(d)
  reflectType(e)
  reflectType(f)
}

func main(){
  demo1()
}

Reflect Type = int64, Name Type : int64,Kind : int64 (6)
Reflect Type = float32, Name Type : float32,Kind : float32 (13)
Reflect Type = int32, Name Type : int32,Kind : int32 (5)
Reflect Type = main.myInt, Name Type : myInt,Kind : int (2)
Reflect Type = main.person, Name Type : person,Kind : struct (25)
Reflect Type = main.book, Name Type : book,Kind : struct (25)

// 通过反射获取变量的值
func reflectTypeValue(x interface{}) {
  t := reflect.TypeOf(x)
  v := reflect.ValueOf(x)
  k := v.Kind()   // 获取的是值的种类
  switch k {
  case reflect.Int64:
    // v.Int()从反射中获取整型的原始值，然后通过int64()强制类型转换
    fmt.Printf("type is int64, value is %d\n", int64(v.Int()))
  case reflect.Float32:
    // v.Float()从反射中获取浮点型的原始值，然后通过float32()强制类型转换
    fmt.Printf("type is float32, value is %f\n", float32(v.Float()))
  case reflect.Float64:
    // v.Float()从反射中获取浮点型的原始值，然后通过float64()强制类型转换
    fmt.Printf("type is float64, value is %f\n", float64(v.Float()))
  case reflect.Bool:
    // v.Bool()从反射中获取布尔型的原始值，然后通过Bool()强制类型转换
    fmt.Printf("type is bool, value is %v\n", bool(v.Bool()))
  }
  fmt.Printf("Reflect Type = %v, Reflect Value = %v, Name : %v, Kind : %s (%d)\n\n", t, v, t.Name(), v.Kind(), v.Kind())
}

// 通过反射设置变量的值(此种方式会报错)
func reflectSetValue1(x interface{}) {
  t := reflect.TypeOf(x)
  v := reflect.ValueOf(x)
  // 使用默认方式修改的是副本，reflect包会引发panic
  if v.Kind() == reflect.Int64 {
    v.SetInt(200)
  }
  fmt.Printf("Type %v, Value %v\n", t, v)
}

// 通过反射设置变量的值
func reflectSetValue2(x interface{}) {
  t := reflect.TypeOf(x)
  v := reflect.ValueOf(x)
  // 反射中使用 Elem()方法获取指针对应的值
  if v.Elem().Kind() == reflect.Int64 {
    v.Elem().SetInt(200)
  }
  fmt.Printf("Type %v, Value %v\n", t, v)
}

func demo2() {
  // 将常规类型初始化并设置值，然后通过反射获取值
  var a int = 1024
  var b float32 = 3.14
  reflectTypeValue(a)
  reflectTypeValue(b)

  // 将int类型的原始值转换为reflect.Value类型
  c := reflect.ValueOf(10)
  fmt.Printf("Type c : %T, Value c : %v\n", c, c)
  reflectTypeValue(c)

  // 通过反射设置变量的值（两种方法）
  var d int64 = 65535
  // reflectSetValue1(d) //panic: reflect: reflect.Value.SetInt using unaddressable value
  reflectSetValue2(&d) // 修改是的指针指向的值
  fmt.Println("通过反射设置变量(d)的值: ", d)
}

func main(){
  demo2()
}

Reflect Type = int, Reflect Value = 1024, Name : int, Kind : int (2)

type is float32, value is 3.140000
Reflect Type = float32, Reflect Value = 3.14, Name : float32, Kind : float32 (13)

type is bool, value is true
Reflect Type = bool, Reflect Value = true, Name : bool, Kind : bool (1)

Type c : reflect.Value, Value c : 10
Reflect Type = reflect.Value, Reflect Value = <int Value>, Name : Value, Kind : struct (25)

Type *int64, Value 0xc0000ba040
通过反射设置变量(d)的值:  200

package main

import (
  "fmt"
  "reflect"
)

type b struct{}

func (t *b) Demo() int {
  fmt.Print("我是通过Call调用的Demo方法，")
  return 1024
}

func main() {
  // (1) *int类型空指针 : 必须是通道、函数、接口、映射、指针、切片之一
  var a *int
  fmt.Println("var a *int IsNil:", reflect.ValueOf(a).IsNil())
  // (2) nil值 : 除了IsValid、String、Kind之外的方法都会导致panic。
  fmt.Println("nil IsValid:", reflect.ValueOf(nil).IsValid())

  // (3) 实例化一个匿名结构体
  b1 := struct{}{}
  b2 := struct {
    abc string
  }{}

  // (4) 实例化一个结构体
  b3 := new(b)

  // 尝试从结构体中查找"abc"字段
  fmt.Println("b1是否存在的结构体成员 abc ? :", reflect.ValueOf(b1).FieldByName("abc").IsValid()) // 不存在
  fmt.Println("b2是否存在的结构体成员 abc ? :", reflect.ValueOf(b2).FieldByName("abc").IsValid()) // 存在

  // 尝试从结构体中查找"demo"方法
  fmt.Println("b1是否存在的结构体方法 Demo ? :", reflect.ValueOf(b1).MethodByName("Demo").IsValid())            //不存在
  fmt.Println("b3是否存在的结构体方法 Demo ? :", reflect.ValueOf(b3).MethodByName("Demo").IsValid())            //存在
  fmt.Println("b3结构体Demo方法返回值类型: ", reflect.ValueOf(b3).MethodByName("Demo").Call([]reflect.Value{})) //输出执行其方法以及返回值的类型 （特别注意，先执行调用后返回类型，并输出）


  // (4) map 	尝试从map中查找一个不存在的键
  c := map[string]int{}
  c["WeiyiGeek"] = 1024
  fmt.Println("map中是否存在WeiyiGeek的键：", reflect.ValueOf(c).MapIndex(reflect.ValueOf("WeiyiGeek")).IsValid())
  fmt.Println("map中是否存在Geek的键：", reflect.ValueOf(c).MapIndex(reflect.ValueOf("Geek")).IsValid())
}

var a *int IsNil: true
nil IsValid: false
b1是否存在的结构体成员 abc ? : false
b2是否存在的结构体成员 abc ? : true
b1是否存在的结构体方法 Demo ? : false
b3是否存在的结构体方法 Demo ? : true
我是通过Call调用的Demo方法，b3结构体Demo方法返回值类型:  [<int Value>]
map中是否存在WeiyiGeek的键： true
map中是否存在Geek的键： false

type StructField struct {
  Name    string      // 字段的名字。
  PkgPath string      // 非导出字段的包路径，对导出字段该字段为""。参见 http://golang.org/ref/spec#Uniqueness_of_identifiers
  Type      Type      // 字段的类型
  Tag       StructTag // 字段的标签
  Offset    uintptr   // 字段在结构体中的字节偏移量
  Index     []int     // 用于Type.FieldByIndex时的索引切片
  Anonymous bool      // 是否匿名字段
}

package main

import (
  "fmt"
  "reflect"
)

type student struct {
  Name  string `json:"name" person:"weiyigeek"` // 可以有多个Tag
  Score int    `json:"score" person:"geek"`
}

// 给student添加两个方法 Study和Sleep(注意首字母大写)
func (s student) Study() string {
  msg := "[Study] 好好学习，天天向上。"
  fmt.Println(msg)
  return msg
}

func (s student) Sleep() string {
  msg := "[Sleep] 好好睡觉，快快长大。"
  fmt.Println(msg)
  return msg
}

// 结构体反射示例演示方法
func Reflectstruct(x interface{}) {
  // (2) 获取 stu1 对象反射类型信息,输出对象名称以及对象种类
  t := reflect.TypeOf(x)
  v := reflect.ValueOf(x)
  fmt.Println("reflect.TypeOf ->", t.Name(), t.Kind()) // student struct
  fmt.Println("reflect.ValueOf ->", v, v.Kind())       // {WeiyiGeek 90} struct
  fmt.Println()

  // (3) 通过for循环遍历结构体的所有字段信息(方式1)
  for i := 0; i < t.NumField(); i++ {
    field := t.Field(i)
    //fmt.Print(v.Field(i).Call([]reflect.Value{}))
    fmt.Printf("name:%s index:%d type:%v json tag: %v  person tag:%v , Field Anonymous: %v\n", field.Name, field.Index, field.Type, field.Tag.Get("json"), field.Tag.Get("person"), field.Anonymous)
  }

  // (4) 通过字段名获取指定结构体字段信息(方式2)
  if scoreField, ok := t.FieldByName("Score"); ok {
    fmt.Printf("\nname:%s index:%d type:%v json tag:%v , Field Anonymous: %v\n", scoreField.Name, scoreField.Index, scoreField.Type, scoreField.Tag.Get("json"), scoreField.Anonymous)
  }

  // (5) 通过for循环遍历结构体的所有方法信息
  fmt.Println("reflect.TypeOf NumMethod->", t.NumMethod())
  fmt.Println("reflect.ValueOf NumMethod->", v.NumMethod())
  for i := 0; i < v.NumMethod(); i++ {
    methodType := v.Method(i).Type()
    fmt.Printf("method name:% s，method: %s\n", t.Method(i).Name, methodType)
    // 通过反射调用方法传递的参数必须是 []reflect.Value 类型
    var args = []reflect.Value{}
    // 相当于依次调用结构体中的方法
    v.Method(i).Call(args)
  }

  // (6) 通过方法名获取指定的结构体方法并执行
  methodSleep := v.MethodByName("Sleep")
  methodSleepType := methodSleep.Type()
  fmt.Printf("Reflect Method ptr:%v，method Type: %v\n", methodSleep, methodSleepType)
  // 通过反射调用方法传递的参数必须是 []reflect.Value 类型
  var args = []reflect.Value{}
  // 相当调用 结构体的 Sleep() 方法
  methodSleep.Call(args)
}

func main() {
  // (1) 实例化 student 结构体
  stu := student{
    Name:  "WeiyiGeek",
    Score: 90,
  }
  Reflectstruct(stu)
}

reflect.TypeOf -> student struct
reflect.ValueOf -> {WeiyiGeek 90} struct

name:Name index:[0] type:string json tag: name  person tag:weiyigeek , Field Anonymous: false
name:Score index:[1] type:int json tag: score  person tag:geek , Field Anonymous: false

name:Score index:[1] type:int json tag:score , Field Anonymous: false
reflect.TypeOf NumMethod-> 2
reflect.ValueOf NumMethod-> 2
method name:Sleep，method: func() string
[Sleep] 好好睡觉，快快长大。
method name:Study，method: func() string
[Study] 好好学习，天天向上。
Reflect Method ptr:0x4ae080，method Type: func() string
[Sleep] 好好睡觉，快快长大。

//# (1) 反射得到传递对象的类型 (类型相关使用)
t := reflect.TypeOf(d)
fmt.Println("参数校验:", t, t.Kind(), t.Elem().Kind())  // # 参数校验 *main.Config ptr struct
for i := 0; i < t.Elem().NumField(); i++ { // #  t.Elem() 拿取指针中的元素属性相关信息
  field := t.Elem().Field(i)   // 遍历单个元素字段信息指定index。
  tag := field.Tag.Get("ini")  // 获取单个元素字段中 ini tag 属性值
}

//# (2) 反射得到传递对象的值  (值相关使用)
v := reflect.ValueOf(d)
sValue := v.Elem().FieldByName(structName) // 此处反射得到嵌套结构体指定字段名称值信息
sType := sValue.Type()                     // 此处反射得到嵌套结构体类型信息
for i := 0; i < sValue.NumField(); i++ {   // 字段名称值信息也可获取字段数量，同上面一致
    field := sType.Field(i) // 反射类型信息中存储了嵌套结构体中的Tag信息
    fieldType = field       // 反射类型信息中存储了嵌套结构体中的filed信息以供后续值类型判断使用}

func hello() {
  fmt.Println("Hello Goroutine!")
}
func main() {
  go	hello()               // 在调用hello函数前面加上关键字go，即启动一个goroutine去执行hello这个函数。
  fmt.Println("main goroutine done!")
 	time.Sleep(time.Second) // 如果不加此延时，则执行结果只打印了main goroutine done!，并不会打印Hello Goroutine!
}

var wg sync.WaitGroup
func hello(i int) {
  defer wg.Done() // goroutine结束就登记-1
  fmt.Println("Hello Goroutine!", i)
}
func main() {

  for i := 0; i < 10; i++ {
    wg.Add(1) // 启动一个goroutine就登记+1
    go hello(i)
  }
  wg.Wait() // 等待所有登记的goroutine都结束
}

package main
import (
  "fmt"
  "time"
)
// 方式1，常规函数方式
func hello(count int) {
  fmt.Printf("欢迎你第 %d 次\n", count)
}
func demo1() {
  for i := 0; i < 5; i++ {
    go hello(i) // 开启一个单独的goroutine去执行hello函数(任务)
  }
}

// 方式2.匿名函数方式
func demo2() {
  for i := 0; i < 5; i++ {
    go func(count int) {
      fmt.Printf("第 %d 次欢迎你\n", count)
    }(i)
  }
}

// 程序启动之后会创建一个主Goroutine去执行。
func main() {
  fmt.Println("[*] main start")
  demo1()
  demo2()
  time.Sleep(time.Second)  // 最暴力简单的延时函数
  fmt.Println("[-] main end")
}
// 如果main函数结束了，则由main启动的goroutine也结束了。

[*] main start
第 4 次欢迎你
欢迎你第 0 次
欢迎你第 1 次
欢迎你第 2 次
欢迎你第 3 次
欢迎你第 4 次
第 0 次欢迎你
第 1 次欢迎你
第 2 次欢迎你
第 3 次欢迎你  # 你会发现输出完此行时，会有卡顿。这是由于未到延时时间代码便执行完毕，所以终端处于阻塞模式，等待延时时间得到来。
[-] main end

// 优雅的使用 goroutine 并行调度。
package main
import (
  "fmt"
  "math/rand"
  "sync"
  "time"
)
// 实例化结构体得到对象
var wg sync.WaitGroup
// goroutine 将调用的函数
func f1() {
  defer wg.Done() // goroutine结束就登记-1
  fmt.Println("输出的随机数：", rand.Intn(10))
}
// 当main函数任务中所有的goroutine都结束了，才结束main函数
func main() {
  fmt.Println("Start Main")
  // goroutine 调用
  for i := 0; i < 10; i++ {
    rand.Seed(time.Now().Unix()) // 随机数种子传入的是一个int64类型
    wg.Add(1)  // 启动一个goroutine就登记+1
    go f1()
  }
  wg.Wait() 	// 监听并等待main中的goroutine是否都运行结束(等待wg组为0时)。
  fmt.Println("End Main")  // 输出再也没有卡顿了
}

Start Main
输出的随机数： 2
输出的随机数： 2
输出的随机数： 8
输出的随机数： 2
输出的随机数： 1
输出的随机数： 7
输出的随机数： 6
输出的随机数： 2
输出的随机数： 7
输出的随机数： 0
End Main   // 此处输出再也没有卡顿了。

package main
import (
  "fmt"
  "runtime"
  "sync"
)

var wg sync.WaitGroup

func a() {
  defer wg.Done()
  for i := 0; i < 6; i++ {
    println("Func A() :", i)
  }
}

func b() {
  defer wg.Done()
  for i := 0; i < 6; i++ {
    println("Func B() :", i)
  }
}

func main() {
  fmt.Println("[*] Main Start")
  fmt.Println("当前机器的 CPU 核心数:", runtime.NumCPU()) // NumCPU返回当前进程可用的逻辑CPU数量。
  runtime.GOMAXPROCS(2)  // 占用cpu的两个核
  wg.Add(1)
  go a() // 并发调用a函数（后输出）
  wg.Add(1)
  go b() // 并发调用a函数（先输出）                   
  fmt.Println("当前机器的 goroutine 数:", runtime.NumGoroutine()) // NumGoroutine返回当前存在的goroutine数。
  wg.Wait()
  fmt.Println("[*] Main End")
}

[*] Main Start
当前机器的 CPU 核心数: 4
当前机器的 goroutine 数: 3
[*] Main End
Func B() : 0
Func B() : 1
Func B() : 2
Func B() : 3
Func B() : 4
Func B() : 5
Func A() : 0
Func A() : 1
Func A() : 2
Func A() : 3
Func A() : 4
Func A() : 5
// 结果说明:  Mac 可以复现成功，而Linux与Windows还是一个goroutine任务做完后再做另外一个goroutine任务,其结果如上。
// 当两个任务只有一个逻辑核心，此时是做完一个任务再做另一个任务。 
// 当将逻辑核心数设为2，此时两个任务并行执行，即理想的状态是做一个任务a再做一个任务b，进行交叉执行。

var ch1 chan int   // 声明一个传递整型的通道
var ch2 chan bool  // 声明一个传递布尔型的通道
var ch3 chan []int // 声明一个传递int切片的通道

var ch chan int
fmt.Println(ch)   // 未初始返回 <nil>

ch4 := make(chan int) // 必须用make函数初始化之后才能使用
ch5 := make(chan bool)
ch6 := make(chan []int,10)  // 带缓冲区的

// 定义一个通道(初始化通道)
ch := make(chan int)

// 发送 send
ch <- 10 // 把10发送到ch中

// 接收 receive
x := <-ch  // 从ch中接收值并赋值给变量x
<-ch       // 从ch中接收值，忽略结果

// 关闭 close
close(x)

* 对一个关闭的通道再发送值就会导致panic。
* 对一个关闭的通道进行接收会一直获取值直到通道为空。
* 对一个关闭的并且没有值的通道执行接收操作会得到对应类型的零值。
* 关闭一个已经关闭的通道会导致panic。

func main() {
  ch := make(chan int)
  ch <- 10  // 代码会阻塞在 ch <- 10这一行代码形成死锁
  fmt.Println("发送成功")
}

fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
.../src/github.com/main.go:8 +0x50

func recv(c chan int) {
  ret := <-c
  fmt.Println("接收成功", ret)
}
func main() {
  ch := make(chan int)
  go recv(ch) // 启用goroutine从通道接收值
  ch <- 10
  fmt.Println("发送成功")
}

func main() {
  ch := make(chan int, 1) // 创建一个容量为1的有缓冲区通道
  ch <- 10
  fmt.Println("发送成功")
}

package main

import (
  "fmt"
  "sync"
)

// make 函数申请内存空间的传入对象（实例化三种类型）
var s []int          // slice 切片
var m map[string]int // map 字典映射
var c chan int       // 指定通道中元素的类型

// 定义全局的waitGroup
var wg sync.WaitGroup

// 无缓冲的通道示例
func noBuffer() {
  fmt.Println(c)      // 未初始化的通道返回 nil （未向内存中申请空间）
  c := make(chan int) // 不带缓冲区通道的初始化 （但必须有对应的接收）
  fmt.Println("将 10 发生到 channel c 之中")
  wg.Add(1)
  go func() { // 并行任务的顺序非常重要，此处不能放在 c <- 10 后否则终端将会一直处于阻塞状态
    defer wg.Done()
    x := <-c
    fmt.Printf("Backgroup Goroutine 从 channel c 中取得 %v \n\n", x)
  }()
  c <- 10 // 将 10 发生到 channel c 之中（注意此行放的顺序）
  wg.Wait()
  defer close(c) // 关闭通道
}

// 有缓冲的通道示例
func useBuffer() {
  fmt.Println(c)        // 未初始化的通道返回 nil （未向内存中申请空间）
  c = make(chan int, 2) // 带缓冲区通道的初始化
  fmt.Println("通道缓冲数量（发送前）:", len(c))
  c <- 10                                // 将 10 发生到 channel c 之中
  fmt.Println("同样将 10 发生到 channel c 之中") // 此处将不会阻塞
  c <- 20                                // 将 10 发生到 channel c 之中
  fmt.Println("然后将 20 发生到 channel c 之中") // 如何缓冲区通道初始化为1，则此处将阻塞,如果初始化通道缓冲区大于等于2将会不阻塞
  fmt.Println("通道缓冲数量（发送后）:", len(c))
  x := <-c
  fmt.Printf("第一次，从channel c中取到了 %v\n", x)
  x = <-c
  fmt.Printf("第二次，从channel c中取到了 %v\n", x)
  fmt.Printf("channel c ptr = %p \n", c)
  defer close(c) // 关闭通道
}

func main() {
  noBuffer()
  useBuffer()
}

<nil>
将 10 发生到 channel c 之中
Backgroup Goroutine 从 channel c 中取得 10 

<nil>
通道缓冲数量: 0
同样将 10 发生到 channel c 之中
然后将 20 发生到 channel c 之中
通道缓冲数量: 2
第一次，从channel c中取到了 10
第二次，从channel c中取到了 20
channel c ptr = 0xc0000240e0

package main

import (
  "fmt"
  "sync"
)

// channel 遍历实践操作
var wg sync.WaitGroup

// 方式1
func method1() {
  ch1 := make(chan int) // 不带缓冲区
  ch2 := make(chan int)
  // 开启goroutine将1~9的数发送到ch1中
  go func() {
    for i := 0; i < 10; i++ {
      ch1 <- i
    }
    close(ch1) // 关闭通道 ch2 （此时只能读不能写）
  }()
  // 开启goroutine从ch1中接收值，并将该值的平方发送到ch2中
  go func() {
    for {
      i, ok := <-ch1 // 通道关闭后再取值到末尾时，ok=false 【关键点值得学习】
      if !ok {
        break
      }
      ch2 <- i * i // 同样求取通道的平方
    }
    close(ch2) // 关闭通道 ch2 （此时只能读不能写）
  }()
  // 在主goroutine中从ch2中接收值打印
  fmt.Println("方式1:")
  for i := range ch2 { // 通道关闭后会退出for range循环
    fmt.Printf("%d ", i)
  }
}

// 负责将10～19发送到ch1中
func f1(ch1 chan int) {
  defer wg.Done()
  for i := 10; i < 20; i++ {
    ch1 <- i
  }
  close(ch1) // 关闭通道 ch1 （此时只能读不能写）
}

// 负责将接收ch1值的值进行平方运算
func f2(ch1, ch2 chan int) {
  defer wg.Done()
  for num := range ch1 {   【关键点】
    ch2 <- num * num
  }
  close(ch2) // 关闭通道 ch2 （此时只能读不能写）
}

// 方式2
func method2() {
  ch1 := make(chan int, 10) // 带缓冲区
  ch2 := make(chan int, 10)
  // goroutine 等待组数量设置
  wg.Add(2)
  // 开启 goroutine
  go f1(ch1)
  go f2(ch1, ch2)
  // 等待全部 goroutine 任务执行完毕
  wg.Wait()
  fmt.Println("方式2:")
  // 通道关闭后会退出for range循环
  for ret := range ch2 {
    fmt.Printf("%d ", ret)
  }
}

func main() {
  // 匿名函数
  method1()
  fmt.Println()
  // 常规函数
  method2()
}

// 函数参数 out： 一个只写单向通道。
func counter(out chan<- int) {
  for i := 0; i < 100; i++ {
    out <- i
  }
  close(out)
}

// 函数参数 out： 一个只写单向通道,函数参数 in: 一个只读单向通道。
func squarer(out chan<- int, in <-chan int) {
  for i := range in {
    out <- i * i
  }
  close(out)
}

// 函数参数 in : 一个只读单向通道。
func printer(in <-chan int) {
  for i := range in {
    fmt.Println(i)
  }
}

func main() {
  ch1 := make(chan int)
  ch2 := make(chan int)
  go counter(ch1) // ch1 此时只写
  go squarer(ch2, ch1) // ch2 此时只写，ch1 此时只读
  printer(ch2) // ch2 此时只读
}

// Unidirectional channel
var wg sync.WaitGroup
var once sync.Once

// 通道只写操作
func f1(ch1 chan<- float64) {
  defer wg.Done()
  for i := 0; i < 10; i++ {
    ch1 <- float64(i)
  }
  close(ch1)
}

// 通道只写与只读操作
func f2(ch2 chan<- float64, ch1 <-chan float64) {
  defer wg.Done()
  for i := range ch1 {
    ch2 <- math.Pow(i, 3)
  }
  // 确保某个操作只执行一次，防止因为通道关闭而其他并发(进程)不能读取
  anonymousefun := (func() {
    close(ch2)
  })
  once.Do(anonymousefun)
}

func main() {
  ch1 := make(chan float64, 10) // 带缓冲区的通道
  ch2 := make(chan float64, 10) // 带缓冲区的通道
  wg.Add(3)
  go f1(ch1)
  go f2(ch2, ch1) // 多次 goroutine 同一个函数
  go f2(ch2, ch1)
  wg.Wait()
  // 循环遍历，直到读取到末尾
  for {
    x, ok := <-ch2
    if !ok {
      break
    }
    fmt.Printf("%.0f ", x)
  }
  fmt.Println()
}

// goroutine 同步等待组
var wg sync.WaitGroup
var one sync.Once

func worker(id int, jobs <-chan int, results chan<- int) {
  defer wg.Done()
  for j := range jobs {
    fmt.Printf("worker:%d start job:%d\n", id, j)  // start
    time.Sleep(time.Millisecond * 500)            // 延时500s查看效果比较明显
    fmt.Printf("worker:%d end job:%d\n", id, j)    // end
    results <- j * 2
  }
  // 保证调用的函数只执行一次 (关键点)
  one.Do(func() {
    close(results)
  })
}

// 五个任务给3给goroutine池执行
func main() {
  jobs := make(chan int, 100)
  results := make(chan int, 100)
  // goroutine 池(此处3个goroutine组成)
  wg.Add(3)
  for w := 1; w <= 3; w++ {
    go worker(w, jobs, results) // 当执行到第五的一个任务后将介绍（所以一共会打印10次）
  }
  // 设置5个任务
  for j := 1; j <= 5; j++ {
    jobs <- j
  }
  // 保证调用的函数只执行一次 (关键点)
  one.Do(func() {
    close(jobs)
  })
  wg.Wait()
  // 输出结果
  fmt.Println("results channle length: ", len(results)) // 长度为 5
  // 方式1,打印后阻塞(会一直从channel中取数)
  // for {
  // 	x, ok := <-results  // results 通道被关闭时ok=False。
  // 	if !ok {
  // 		fmt.Println(ok)
  // 		break
  // 	}
  // 	fmt.Println(ok, x)
  // }

  // 方式2,打印后阻塞(会一直从channel中取数)
  // for i := range results {
  // 	fmt.Println(i)
  // }

  // 此种方式不会阻塞
  for a := 1; a <= 5; a++ {
    <-results
  }
}

worker:3 start job:1
worker:2 start job:3
worker:1 start job:2
worker:1 end job:2
worker:1 start job:4
worker:2 end job:3
worker:2 start job:5
worker:3 end job:1
worker:1 end job:4
worker:2 end job:5
results channle length:  5

func worker(id int, jobs <-chan int, results chan<- int, notify chan<- struct{}) {
  for j := range jobs {
    time.Sleep(time.Millisecond * 500)          // 延时500s查看效果比较明显
    fmt.Printf("worker:%d end job:%d\n", id, j) // end
    results <- j * 2
    notify <- struct{}{} // 任务执行信号标识,实例化匿名结构体,如此使用非常节省空间.
  }

}

func main() {
  // 1.初始化通道
  jobs := make(chan int, 100)
  results := make(chan int, 100)
  notify := make(chan struct{}, 5) // 作为信号使用,通道类型采用匿名结构体,占用的系统资源较少(常用值得学习),此处作为并发任务执行完毕通知.

  // 2.生成五个任务
  go func() {
    for i := 1; i <= 5; i++ {
      jobs <- i
    }
    close(jobs) // 给通道传递完值后关闭
  }()

  // 3.开启三个Goroutine (并发池)
  for w := 1; w <= 3; w++ {
    go worker(w, jobs, results, notify)
  }

  // 4.通过信号变量,验证五个任务是否执行完毕,如果晚报则关闭results通道
  go func() {
    // 循环五次
    for i := 0; i < 5; i++ {
      <-notify
    }
    // 关闭通道，如果不关闭将一直阻塞
    close(results)
  }()

  // 5.遍历已关闭的通道值
  for res := range results {
    fmt.Println(res)
  }
}

worker:2 end job:2
worker:3 end job:3
worker:1 end job:1
4
6
2
worker:2 end job:4
8
worker:3 end job:5
10

for{
  // 尝试从ch1接收值
  data, ok := <-ch1
  // 尝试从ch2接收值
  data, ok := <-ch2
  …
}

select{
  case <-ch1:
      ...
  case data := <-ch2:
      ...
  case ch3<-data:
      ...
  default:
      默认操作
}

package main
import (
  "fmt"
  "sync"
)
var wg sync.WaitGroup
func main() {
  // 示例1
  ch1 := make(chan int, 1)
  fmt.Println("// 示例 1	")
  for i := 0; i < 10; i++ {
    select {
      case x := <-ch1:
        fmt.Printf("index : %d , x = %d\n", i, x) // 通道缓冲区为1时,结果时可以预测的.
      case ch1 <- i: // 将会把(变量i)偶数值传给ch1通道
      default:
        fmt.Printf("index : %d , default\n", i)
    }
  }

  // 示例2
  ch2 := make(chan int, 2)
  fmt.Println("// 示例 2")
  wg.Add(1)
  go func() {
    wg.Done()
    for i := 1; i <= 5; i++ {
      ch2 <- i + i
    }
    close(ch2)
  }()
  wg.Wait()
  for i := 1; i <= 5; i++ {
    select {
      case j := <-ch2:
        fmt.Println("case 1: ", i, j) // 通道缓冲区为大于1时,结果是不可以预测的.
      case ch2 <- i:
        fmt.Println("case 2: ch2 <- i", i)
      default:
        fmt.Println("默认执行", i)
    }
  }
}

// 示例 1	
index : 1 , x = 0
index : 3 , x = 2
index : 5 , x = 4
index : 7 , x = 6
index : 9 , x = 8
// 示例 2
case 1:  1 2
case 1:  2 4
case 2: ch2 <- i 3
case 1:  4 6
case 1:  5 3  // 注意通道是先进先出类似于队列结构。

var x int64
var wg sync.WaitGroup

func add() {
  for i := 0; i < 5000; i++ {
    x = x + 1
  }
  wg.Done()
}
func main() {
  wg.Add(2)
  go add()  // 两个 goroutine 执行add任务
  go add() 
  wg.Wait()
  fmt.Println(x) // 由于数据竞争的影响，可能导致最后的结果与期待的不符。输出: 5702 理想为10000
}

var x int64
var wg sync.WaitGroup
var lock sync.Mutex

func add() {
  for i := 0; i < 5000; i++ {
    lock.Lock() // 加锁
    x = x + 1
    lock.Unlock() // 解锁
  }
  wg.Done()
}
func main() {
  // 设置两个goroutine池进行执行add任务
  poolCount := 2
  wg.Add(poolCount)
  for i := 0; i < poolCount; i++ {
    go add()
  }
  wg.Wait()
  fmt.Println(x)  // 输出值为预期相同 10000
}

# 加、解 读锁
rwlock.RLock()       # 对读操作进行锁定        
rwlock.RUnlock()     # 对读锁定进行解锁

# 加、解 写锁
sync.RWMutex.Lock()   # 对写操作进行锁定
sync.RWMutex.Unlock() # 对写锁定进行解锁

var (
  x      int64
  wg     sync.WaitGroup
  rwlock sync.RWMutex
)

func write() {
  rwlock.Lock() // 加写锁
  x = x + 1
  time.Sleep(10 * time.Millisecond) // 假设写操作耗时10毫秒
  rwlock.Unlock()                   // 解写锁
  wg.Done()
}

func read() {
  rwlock.RLock()               // 加读锁
  time.Sleep(time.Millisecond) // 假设读操作耗时1毫秒
  rwlock.RUnlock()             // 解读锁
  wg.Done()
}

func main() {
  start := time.Now()
  for i := 0; i < 10; i++ {
    wg.Add(1)
    go write()
  }

  for i := 0; i < 1000; i++ {
    wg.Add(1)
    go read()
  }
  wg.Wait()
  end := time.Now()
  fmt.Printf("耗费时间 ：%v, x = %d \n", end.Sub(start), x) 
  // 执行结果 => 耗费时间 ：104.906297ms, x = 10 
}

// 修改内存地址中值为delta并返回新值
func AddInt64(addr *int64, delta int64) (new int64)
// 读取内存地址中的值并返回
func LoadInt64(addr *int64) (val int64)

// 接口声明
type Counter interface {
  Inc()
  Load() int64
}

// 普通版
type CommonCounter struct {
  counter int64
}
func (c *CommonCounter) Inc() {
  c.counter++ // 写
}
func (c *CommonCounter) Load() int64 {
  return c.counter // 读
}

// 互斥锁版
type MutexCounter struct {
  counter int64
  lock    sync.Mutex
}
func (m *MutexCounter) Inc() {
  m.lock.Lock()
  defer m.lock.Unlock()
  m.counter++  // 写
}
func (m *MutexCounter) Load() int64 {
  m.lock.Lock()
  defer m.lock.Unlock() 
  return m.counter  // 读
}

// 原子操作版
type AtomicCounter struct {
  counter int64
}
func (a *AtomicCounter) Inc() {
  atomic.AddInt64(&a.counter, 1) // 写
}
func (a *AtomicCounter) Load() int64 {
  return atomic.LoadInt64(&a.counter) // 读
}

func test(c Counter) {
  var wg sync.WaitGroup
  start := time.Now()
  for i := 0; i < 1000; i++ {
    wg.Add(1)
    go func() {
      c.Inc()
      wg.Done()
    }()
  }
  wg.Wait()
  end := time.Now()
  fmt.Println(c.Load(), end.Sub(start))
}

func main() {
  c1 := CommonCounter{} // 非并发安全
  test(&c1)
  c2 := MutexCounter{}  // 使用互斥锁实现并发安全
  test(&c2)
  c3 := AtomicCounter{} // 并发安全且比互斥锁效率更高
  test(&c3)
}

943 1.240583ms
1000 1.514732ms
1000 421.618µs  // 可以看出其性能效率是最高的。