// 普通函数创建 goroutine 语法

go  函数名称(参数列表)　　　　

// 匿名函数创建 goroutine 语法

go func(形参列表) {函数体...}(实参列表)

// 使用 go 创建 goroutine 后，函数的返回值会被忽略

package main

import (

    "fmt"

    "math/rand"

    "time"

)

func listElem(n int) {

    for i:=; i<n; i++ {

        fmt.Println(i)

    }

}

func main() {

    go listElem()        // 若 main 函数中仅有这一句代码，控制台将没有任何输出，因为 main 创建协程后立即推出了，还未来得及执行协程

    //添加以下代码

    var input string

    fmt.Scanln(&input)        // 需要用户输入任意字符 main 才会结束

}

func main() {

    go func() {

        var times int

        for {

            times++

            fmt.Println("tick", times)

            time.Sleep(time.Second)

        }

    } ()

}

// 声明之后必须配合 make 才能使用

var  通道变量  chan  通道类型            // 声明通道；通道类型，通道内的数据类型

通道实例  =  make(chan  数据类型)        // 创建通道；数据类型，通道内传输的元素类型

// eg：

var  ch1  chan  string

ch1   =  make(chan  string)

ch2 := make(chan int)                        // 创建整型类型的通道

ch3 := make(chan interface{})            // 创建空接口类型的通道，可存放任意格式            

ch4 := make(chan *Equip)                  // 创建 Equip 指针类型的通道，可存放 *Equip

// 关闭通道

close(ch1)

// 通道发送数据的语法：  "<-"  操作符

通道变量  <-  值                // 值可以是：变量、常量、表达式、函数返回值、但值的类型必须与通道声明的元素类型一致

// eg

ch := make(chan interface{})            // 创建空接口通道

ch <-                                             // 向通道内放入 0

ch <- "Hello World"                          // 向通道内放入 字符串

// 附：向通道内发送数据时，若没有对应的接收方读取数据，那么发送数据的操作将会一直堵塞。

// 接收数据同样使用  "<-" 操作符

data := <-ch        // 阻塞接收数据

data, ok := <-ch        // 非阻塞接收数据，方未接收到数据时，data为通道类型的零值，ok为false；此方式会造成CPU高占用，实现接收超时检测会配合 select 和 计时器channel进行，一般较少使用

<-ch                        // 接收任意数据，并忽略接收到的数据

// 循环接收

for data := range ch {

    // do something

}

var 通道变量 chan<- 通道类型        // 只写 channel

var 通道变量 <-chan 通道类型        // 只读 channel

var 通道变量 chan 通道类型                // 可读可写 channel

// eg

var wc chan<- string

var rc <-chan string

var ch chan string    

// 关闭 channel

close(ch)    

package main

import (

    "fmt"

    "math/rand"

    "sync"

    "time"

)

var wg sync.WaitGroup

func init() {

    rand.Seed(time.Now().UnixNano())

}

func player(name string, court chan int) {

    /**

    击球比赛 大致流程：

        创建一个数据类型是 int的channel

          创建两个 goroutine（选手），互相进行击球，由于 player 中第一行代码是在阻塞等待接球（从channel中获取数据），所以在main当中需要发出第一个球

          player：

              启动两个 goroutine 后，总有一方会抢先从 channel 中取出数据，那么另一方处于阻塞等待的状态。

              然后判断 通道channel 是否关闭（若已关闭，ok=false ）

              若已经关闭，代表是对方关闭的通道对方输球，则当前选手获胜，退出游戏。

              若上一个判断不成立，则接下来选择一个随机数 并 判断是否可以被 22 整除，以此来决定是否丢球（向通道写入数据，让对方获取【接球】）

                  若无法被整除，当前选手输球，直接关闭通道并退出，此时执行权在另一方选手，从通道取出数据时，发现通道已关闭，那么打印胜利信息。

                  若可以整除，显现当前的击球数，并将其写入到通道，让对方接球。

          以下代表表示主 goroutine 需要等待另两个 goroutine 结束之后才能结束 main

              wg.Add(2)

              defer wg.Done()

              wg.Wait()

    **/

    defer wg.Done() // 函数退出时调用 Done 函数，以此通知 main 函数，当前函数的工作已完成

    for {

        ball, ok := <-court // 等待接球

        if !ok {            // 若通道关闭，则胜利

            fmt.Printf("Player %s Won\n", name)

            return

        }

        // 选择随机数，使用此数判断是否丢球

        n := rand.Intn()

        if n %  ==  {

            fmt.Printf("Player %s Missed\n", name)

            // 关闭通道，表输球

            close(court)

            return

        }

        // 显示击球数，且击球数 +1

        fmt.Printf("Player %s Hit %d\n", name, ball)

        ball++

        // 击球给对方

        court <- ball

    }

}

func main() {

    // 击球比赛

    court := make(chan int)

    wg.Add()            // 表：需等待两个 goroutine

    go player("Juan", court)    // 启动两个选手

    go player("Xiao", court)

    court <-         // 发球

    wg.Wait()        // 等待结束

}

击球比赛

func main() {

    // 带缓冲通道：  创建语法，  通道实例 := make(chan 通道类型，缓存大小)

    bufferCh := make(chan int, )

    fmt.Printf("put data before, channel length: %d\n", len(bufferCh))            // 查看放入数据前通道大小

    bufferCh <-

    bufferCh <-

    bufferCh <-

    close(bufferCh)        // 通道关闭仍然可以从通道中读取数据，但不可发送数据，会引发panic错误，当已关闭的通道中 也没有数据后，不会阻塞获取数据操作，将会返回零值

    fmt.Printf("put data after, channel length: %d\n", len(bufferCh))            // 查看放入数据后通道大小

    data1 := <-bufferCh

    fmt.Printf("get first data: %d\n", data1)

    data2 := <-bufferCh

    fmt.Printf("get secondly data: %d\n", data2)

    data3 := <-bufferCh

    fmt.Printf("get thirth data: %d\n", data3)

    data4 := <-bufferCh

    fmt.Printf("get next data, bur no data anymore, it is %d\n", data4)

}    

// 首先，我们实现并执行一个匿名的超时等待函数

timeout := make(chan bool, )

go func() {

    time.Sleep(1e9) // 等待1秒钟

    timeout <- true

}()

// 然后我们把timeout这个channel利用起来

select {

    case <-ch:

    // 从ch中读取到数据

    case <-timeout:

    // 一直没有从ch中读取到数据，但从timeout中读取到了数据

}

// 一次性接收多个通道的数据，当操作发生时，会执行对应case语句中的响应

select{

    case 操作1:

        响应操作1

    case 操作2:

        响应操作2

    …

    default:

        没有操作情况

}