Go (一) 基础部分5 -- 单元测试,协程(goroutine),管道(channel)

一、单元测试

Go自带一个轻量级的"测试框架testing"和自带的"go test"命令来实现单元测试和性能测试。

1.确保每个函数时可运行，并且运行结果是正确的。
2.确保写出来的代码性能是好的。
3.单元测试能及时的发现程序设计或实现的逻辑错误，使问题及早暴露，便于问题的定位解决。而性能测试的重点在于发现程序设计上的一些问题，让程序能够在高并发的情况下还能保持稳定。

运用测试用例的指令：

go test：运行正确时，无日志，运行错误时，会输出日志。

go test -v：运行正确或者错误都会输出日志。

1.1、单元测试的快速入门（判断一个函数的执行结果是否符合预期）

1.测试用例文件必须以"_test.go"结尾，文件不能命名为：_test.go，test.go，test_xxx.go；

2.测试用例文件内任何 **"Test开头且首字母大写"的函数(例:TestXxx)**都会被执行，文件内不需要写main函数；

3.TestXxx(t testing.T)的形参类型必须时testing.T；

4.出现错误时，可以使用"t.Fatalf"来格式化错误信息，并退出程序；

5."t.Logf"方法可以输出相应的日志；

6.测试用例函数，没有main函数，也正常执行了，这也是测试用例的方便之处；

7.PASS表示测试用例运行成功，FAIL表示测试用例运行失败；

8.测试单个文件"cal_test.go"，一定要带上被测试的原文件：go test-vcal_test.go****main.go

9.测试单个方法：**go test -v-test.run(固定参数)**TestAddUpper(函数名)

package main

import (
    "fmt"
    "testing"
)

// 使用go test命令，能够自动执行如下形式的任何函数
// func TestXxx(*testing.T)，其中Xxx可以是任何字母或字符串(第一个字母不能是[a-z])
func TestAddUpper(t *testing.T)  {
    res := AddUpper(10)
    if res != 55 {
        t.Fatalf("AddUpper函数执行错误,期望值:%v 返回值:%v",55,res)
    }
    t.Logf("AddUpper函数执行成功")
}

func TestSudada(t *testing.T)  {
    fmt.Println("函数TestSudada被执行")
}

测试函数：xxx.go，文件内包含要测试的"函数"，文件内不需要写main函数。

package main

// xxx_test.go 内调用的函数
func AddUpper(n int) int  {
    res:=0
    for i:=0;i<=10;i++{
        res+=i
    }
    return res
}

"go test"命令执行错误时的返回结果

"go test"命令执行正确时的返回

1.2、单元测试-综合案例

测试用例文件：store_test.go（测试结构体的序列化和反序列化）

package main

import (
    "fmt"
    "testing"
)

// 测试用例TestStore
func TestStore(t *testing.T)  {
    // 先创建结构体变量
    var monster = Monster{
        Name: "牛魔王",
        Age: 18,
        Skill: "蛮牛冲撞",
    }
    StoreRes:=monster.Store()
    if !StoreRes {
        fmt.Println("Store函数测试错误，返回值不为ture")
    }
    // 返回值：
    // === RUN   TestStore
    // Store方法执行成功，test.txt文件保存成功
    // --- PASS: TestStore (0.00s)
}

// 测试用例TestReStore
func TestReStore(t *testing.T)  {
    // 先创建结构体变量
    var monster = Monster{}
    ReStoreRes:=monster.ReStore()
    if !ReStoreRes {
        fmt.Println("ReStore函数测试错误，返回值不为ture")
    }
    // 返回值：
    // === RUN   TestReStore
    // ReStore方法执行成功，反序列化的值为 &{牛魔王 18 蛮牛冲撞}
    // --- PASS: TestReStore (0.00s)
}

被测试对象：main.go（结构体和方法）

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
)

type Monster struct {
    Name string
    Age int
    Skill string
}


func (this *Monster)Store() bool {
    // 序列化结构体变量
    data, err := json.Marshal(this)
    if err != nil {
        fmt.Println("序列化失败",err)
        return false
    }
    // 把序列化后的数据，写入到test.txt文件内
    WriteFileErr :=ioutil.WriteFile("test.txt",data,0666)
    if WriteFileErr != nil{
        fmt.Println("文件保存失败",WriteFileErr)
        return false
    }
    fmt.Println("Store方法执行成功，test.txt文件保存成功")
    return true
}


func (this *Monster)ReStore() bool {
    // 从文件中，读取序列化的数据
    data, ReadFileErr := ioutil.ReadFile("test.txt")
    if ReadFileErr != nil{
        fmt.Println("文件读取失败",ReadFileErr)
        return false
    }
    // 将读到的数据，执行反序列化
    err := json.Unmarshal(data, this)
    if err != nil{
        fmt.Println("反序列化失败",err)
        return false
    }
    fmt.Println("ReStore方法执行成功，反序列化的值为：",this)
    return true
}

二、goroutine（协程）

一个go线程上，可以起多个协程，协程是轻量级的线程。

Go协程的特点：有独立的栈空间，共享程序堆空间，调度由用户控制，协程是轻量级的线程

2.1、gorouting快速入门案例

协程的执行流程：
1.程序开始（进程/主线程开始执行）；
2.go test() 开启协程：协程此时开始执；行，如果主线程退出了，那么无论协程是否执行完毕，都会退出；
3.主线程(main)执行代码逻辑；
4.主线程结束（程序退出）。

案例：在主线程中，启动一个gorouting，该协程每隔1秒输出一个"hello world"

package main

import (
    "fmt"
    "time"
)

// 
func test()  {
    for i:=0;i<10;i++ {
        fmt.Println("test() hello world",i)
        time.Sleep(time.Second)
    }
}

func main() {
    // 开启一个协程
    go test()
    for i:=0;i<10;i++ {
        fmt.Println("main() hello world",i)
        time.Sleep(time.Second)
    }
}

// 输出结果
main() hello world 0
test() hello world 0
test() hello world 1
main() hello world 1
main() hello world 2
test() hello world 2
test() hello world 3
main() hello world 3
main() hello world 4
test() hello world 4
test() hello world 5
main() hello world 5
main() hello world 6
test() hello world 6
test() hello world 7
main() hello world 7
main() hello world 8
test() hello world 8
test() hello world 9
main() hello world 9

2.1.1、协程的快速入门小结

1.主线程是物理线程，作用在CPU上。是重量级的，非常耗费cpu资源。

2.协程是从主线程开启的，是轻量级的线程，是逻辑态，对资源消耗相对小。

3.Golang的协程机制是重要的特点，可以轻松开启上万个协程。

2.2、MPG模式

M：操作系统的主线程

P：协程执行需要的上下文

G：协程（gorouting）

2.3、Go设置运行cpu数目

为了充分利用多CPU的优势，在golang程序中，设置运行的cpu数目（go1.8版本之后，默认让程序运行在多核上，可不设置）

package main

import (
    "fmt"
    "runtime"
)

func main() {
    // 常看当前主机的CPU核数
    cpuNum:=runtime.NumCPU()
    fmt.Println(cpuNum)

    // 可以自定义设置golang运行的cpu数
    runtime.GOMAXPROCS(5)
    fmt.Println("ok")
}

三、channel（管道）

在运行程序时，如何知道是否存在资源争抢的问题？

在编译程序时，增加一个参数 -race 即可。

3.1、全局锁的定义和使用

// 定义一个全局互斥锁
var lock sync.Mutex

func main()  {
    // 加锁
    lock.Lock()

    代码逻辑...

    // 解锁
    lock.Unlock()
}

3.2、channel(管道)的基本介绍 - 引用类型

3.2.1、为什么要使用channel

1.channel本质就是一个数据结构-**队列 (先进先出)；
2.线程安全，多gorouting访问时，不需要加锁，就是说channel本身就是线程安全的 **(多个协程操作同一个管道时，不会发生资源竞争问题)；
3.channel是有类型的，一个string类型的channel只能存放string类型数据；

3.2.2、channel的基本语法

var变量名chan****数据类型

**var ****intChan chanint **（intChan用于存放int数据）

*var *mapChan chanmap[int]string* （mapChan用于存放map[int]string数据）*

*var *perChan chanPerson* （perChan用于存放结构体）*

*var **perChan *chan**Person** （perChan用于存放结构体指针）*

说明：

channel是引用类型

channel必须初始化才能雪茹数据，即make后才能使用

3.3、channel的快速入门（管道创建，写数据，读数据）

package main

import "fmt"

func main() {
    // 定义intChan
    var intChan chan int

    // 初始化intChan：初始化类型为chan，类型为int，容量为3
    intChan = make(chan int, 3)

    // 查看管道的值是什么
    fmt.Println(intChan)  // 得到的是一个指针地址

    // 向管道中写入数据（写入的数据数量，不能超过管道的容量，如果超过会报错deadlock）
    intChan<- 10  // "<- 10" 向管道内写入一个数据"10"
    num:=20
    intChan<-num  // "<- num" 向管道内写入一个变量的值"20"

    // 查看管道的长度（追加了2个数据）
    fmt.Println(len(intChan)) // 返回值：2
    // 查看管道的cap(容量)（make时设置的容量为3）
    fmt.Println(cap(intChan)) // 返回值：3

    // 从管道中取出一个值（长度会减少，容量不变）
    var num2 int
    num2 = <-intChan
    fmt.Println(num2) // 返回值为：10
    //var num3 int
    //num3 = <-intChan
    //fmt.Println(num3) // 返回值为：20

    // 取出一个数据，不接收
    <-intChan

    // 管道的数据全部取完后，会报错deadlock
    var num4 int
    num4 = <-intChan
    fmt.Println(num4) // 返回值为：deadlock!
}

3.3.1、channel的注意事项

1.channel定义好了数据类型之后，只能存放指定的数据类型；

2.channel的数据存满之后，就不能在存入了；

3.channel的数据取完之后，才可以继续存入；

4.在没有使用协程的情况下，如果channel的数据取完了，再取的话，就会报错deadlock。

3.3.2、案例1：创建一个intChan，存放int类型的数据，然后取出

package main

import "fmt"

func main() {
    // 定义intChan
    var intChan chan int
    // 初始化chan
    intChan = make(chan int, 10)
    // 给管道添加值
    intChan<-10
    intChan<-20
    intChan<-30
    // 从管道取值
    num1:=<-intChan
    num2:=<-intChan
    num3:=<-intChan
    fmt.Println(num1,num2,num3)
}

3.3.3、案例2：创建一个mapChan，存放map[string]string数据，然后取出

package main

import "fmt"

func main() {
    // 定义chan
    var mapChan chan map[string]string
    // 初始化chan
    mapChan = make(chan map[string]string,10)
    // 给管道添加值（map类型先make）
    m1 := make(map[string]string,10)
    m1["name1"]="北京"
    m1["name2"]="天津"
    m2 := make(map[string]string,10)
    m2["name1"]="上海"
    m2["name2"]="南京"
    mapChan<-m1
    mapChan<-m2

    // 从管道取值
    m11:=<-mapChan
    m22:=<-mapChan
    fmt.Println(m11)  // map[name1:北京 name2:天津]
    fmt.Println(m22)  // map[name1:上海 name2:南京]
}

3.3.4、案例3：创建一个catChan，存放Cat结构体变量数据，然后取出

package main

import "fmt"

type Cat struct {
    Name string
    Age int
}

func main() {
    // 定义chan
    var catChan chan Cat
    // 初始化chan
    catChan = make(chan Cat,10)
    cat1:=Cat{
        Name: "Tom",
        Age: 2,
    }
    cat2:=Cat{
        Name: "TTome",
        Age: 2,
    }
    // 给管道赋值
    catChan<-cat1
    catChan<-cat2

    // 管道取值
    cat11:=<-catChan
    cat22:=<-catChan
    fmt.Println(cat11)  // 返回值：{Tom 2}
    fmt.Println(cat22)  // 返回值：{TTome 2}
}

3.3.5、案例4：创建一个allChan，存放任意类型的数据，然后取出

package main

import "fmt"

type Cat struct {
    Name string
    Age int
}

func main() {
    // 定义chan
    allChan := make(chan any,3)
    // chan赋值
    allChan<-"sudada"
    allChan<-123
    cat:=Cat{
        Name: "Tom",
        Age: 2,
    }
    allChan<-cat
    // 只想获取管道的第三个值时（需要现将前2个值推出）
    <-allChan
    <-allChan
    // 获取到的第三个值
    cat1:=<-allChan
    fmt.Println(cat1)  // 返回值：{Tom 2}

    // 查看管道内值的类型
    fmt.Printf("%T\n",cat1)  // 返回值：main.Cat
    // fmt.Println(cat1.Name)  // 直接获取结构体的值会报错：cat1.Name undefined (type any has no field or method Name)

    // 使用类型断言
    newCat:=cat1.(Cat)
    fmt.Println(newCat.Name) // 返回值：Tom
}

3.4、channel的遍历和关闭

3.4.1、channel的关闭 close(xxxChan)

使用内置函数close()就可以关闭channel，当channel关闭后，就不能在往里面写数据了，但是仍然可以读取数据。

package main

import "fmt"

func main() {
    // 定义并初始化chan
    intChan:=make(chan int,3)
    // 管道赋值
    intChan<-100
    intChan<-200
    // 管道关闭
    close(intChan)
    //intChan<-300  // 管道关闭后，在往里面写数据时，会报错：panic: send on closed channel
    // 管道关闭后，读取值
    num1:=<-intChan
    num2:=<-intChan
    fmt.Println(num1)  // 返回值：100
    fmt.Println(num2)  // 返回值：200
}

3.4.2、channel的遍历（for -- range）

1.在遍历时，如果channel没有关闭，则会出现deadlock的错误。

2.在遍历时，如果channel已经关闭，则会正常遍历数据，遍历完毕后退出。

package main

import "fmt"

func main() {
    // 定义并初始化chan
    intChan:=make(chan int,100)
    // 管道赋值
    for i:=1;i<=100;i++{
        intChan<-i
    }
    // 关闭管道（如果不关闭会报错deadlock）
    close(intChan)

    // for-range遍历管道
    for v:=  range intChan {
        fmt.Println(v)  // 返回值：1...100
    }
}

3.5、gorouting和chnnel结合使用的案例

1.开启一个writeData协程，向管道intChan写入10个整数；

2.开启一个readData协程，从管道intChan内读取10个整数；

3.writeData和readData操作的是同一个管道；

4.主线程需要等待writeData和readData协程都完成工作才退出；

流程图解：

代码实现：

package main

import (
    "fmt"
    "time"
)

func writeData(intChan chan int)  {
    for i:=0;i<10;i++{
        // 写之前等1秒，模拟一边写一边读的场景
        time.Sleep(time.Second)
        // 管道内放入数据
        intChan<-i
        fmt.Println("writeData: ",i)
    }
    // 关闭管道（不在写数据之后，就把管道关闭，但还可以继续读管道的数据）
    close(intChan)
}

func readData(intChan chan int, exitChan chan bool)  {
    for {
        // 读之前等1秒，模拟一边写一边读的场景
        time.Sleep(time.Second)
        // 管道内取值，并判断是否取值成功
        v, ok := <-intChan
        if !ok {
            break
        }
        fmt.Println("readData: ",v)
    }
    // intChan管道内的所有值全部都取出后，往exitChan写一个数据，并关闭管道
    exitChan<-true
    close(exitChan)
}

func main() {
    // 创建2个管道
    intChan := make(chan int,10)
    exitChan := make(chan bool,1)

    // 调用协程
    go writeData(intChan)
    go readData(intChan,exitChan)

    // 主进程读取exitChan管道内的数据，取到值之后再退出，否则就一直等待
    for {
        // 管道内取值，并判断是否取值成功
        _, ok := <-exitChan
        if ok {
            break
        }
    }
}

// 返回值：
//writeData:  0
//readData:  0
//writeData:  1
//readData:  1
//writeData:  2
//readData:  2
//writeData:  3
//readData:  3
//writeData:  4
//readData:  4
//writeData:  5
//readData:  5
//writeData:  6
//readData:  6
//writeData:  7
//readData:  7
//writeData:  8
//readData:  8
//writeData:  9
//readData:  9

3.6、阻塞

编译器在运行时，发现一个管道只有写，而没有读，就会阻塞。（如果有(缓慢的)读取管道内的数据时，就不会阻塞）

举例：管道的容量为10，但是放入管道的数据量超过了10，或者一直没有取出管道内的数据，就会阻塞，报错deadlock；

案例1：一直往管道内写数据，当写入的数据量，超过管道的容量时，就会阻塞，报错deadlock

package main

import (
    "fmt"
)

func writeData(intChan chan int)  {
    for i:=0;i<10;i++{
        // 写之前等1秒，模拟一边写一边读的场景
        //time.Sleep(time.Second)
        // 管道内放入数据
        intChan<-i
        fmt.Println("writeData: ",i)
    }
    // 关闭管道（不在写数据之后，就把管道关闭，但还可以继续读管道的数据）
    close(intChan)
}

func readData(intChan chan int, exitChan chan bool)  {
    for {
        // 读之前等1秒，模拟一边写一边读的场景
        //time.Sleep(time.Second)
        // 管道内取值，并判断是否取值成功
        v, ok := <-intChan
        if !ok {
            break
        }
        fmt.Println("readData: ",v)
    }
    // intChan管道内的所有值全部都取出后，往exitChan写一个数据，并关闭管道
    exitChan<-true
    close(exitChan)
}

func main() {
    // 创建2个管道
    intChan := make(chan int,5)
    exitChan := make(chan bool,1)

    // 调用协程
    go writeData(intChan)
    //go readData(intChan,exitChan)

    // 主进程读取exitChan管道内的数据，取到值之后再退出，否则就一直等待
    for {
        // 管道内取值，并判断是否取值成功
        _, ok := <-exitChan
        if ok {
            break
        }
    }
}

// 返回值： fatal error: all goroutines are asleep - deadlock!

案例2：在往管道内写数据时，如果如果有协程在(缓慢的)去读/取(消费)管道内的数据，那么就不会阻塞

package main

import (
    "fmt"
    "time"
)

func writeData(intChan chan int)  {
    for i:=0;i<10;i++{
        // 写之前等1秒，模拟一边写一边读的场景
        //time.Sleep(time.Second)
        // 管道内放入数据
        intChan<-i
        fmt.Println("writeData: ",i)
    }
    // 关闭管道（不在写数据之后，就把管道关闭，但还可以继续读管道的数据）
    close(intChan)
}

func readData(intChan chan int, exitChan chan bool)  {
    for {
        // 读之前等1秒，模拟一边写一边读的场景
        time.Sleep(time.Second)
        // 管道内取值，并判断是否取值成功
        v, ok := <-intChan
        if !ok {
            break
        }
        fmt.Println("readData: ",v)
    }
    // intChan管道内的所有值全部都取出后，往exitChan写一个数据，并关闭管道
    exitChan<-true
    close(exitChan)
}

func main() {
    // 创建2个管道
    intChan := make(chan int,5)
    exitChan := make(chan bool,1)

    // 调用协程
    go writeData(intChan)
    go readData(intChan,exitChan)

    // 主进程读取exitChan管道内的数据，取到值之后再退出，否则就一直等待
    for {
        // 管道内取值，并判断是否取值成功
        _, ok := <-exitChan
        if ok {
            break
        }
    }
}

// 返回值：
writeData:  0
writeData:  1
writeData:  2
writeData:  3
writeData:  4
readData:  0
writeData:  5
readData:  1
writeData:  6
writeData:  7
readData:  2
readData:  3
writeData:  8
readData:  4
writeData:  9
readData:  5
readData:  6
readData:  7
readData:  8
readData:  9

3.7、协程求素数的实现

统计1-1000个数字中，哪些是素数？

package main

import (
    "fmt"
)

// 往管道内放入1000个数
func putNum(intChan chan int) {
    for i := 0; i < 100; i++ {
        intChan <- i
    }
    // 关闭intChan
    close(intChan)
}

// 从管道intChan内取数据，判断是否为素数，把素数放入primeChan。取完后往exitChan写入一个true
func putPrimeNum(intChan chan int, primeChan chan int, exitChan chan bool) {
    var flag bool
    for {
        // 从管道intChan内取数据
        num,ok:=<-intChan
        // 管道intChan内的数据取完就退出
        if !ok {
            break
        }
        // 假设是素数
        flag = true
        // 判断是否为素数
        for i:=2;i<num;i++{
            if num %i == 0 {  // 为0说明不是素数
                flag = false
                break
            }
        }
        if flag {
            // 把素数放入管道primeChan
            primeChan<-num
        }
    }
    // 向退出的管道exitChan写入一个true即可
    fmt.Println("协程putPrimeNum取不到数据，退出")
    exitChan<-true
}

func main() {
    // 存放整数的chan
    var intChan chan int
    intChan = make(chan int, 100)
    // 存放素数的chan
    var primeChan chan int
    primeChan = make(chan int, 200)
    // 标识退出的chan
    var exitChan chan bool
    exitChan = make(chan bool, 4)

    // 开启协程，向intChan放入1000个数
    go putNum(intChan)
    // 开启协程，从intChan里面取数据，并判断是否为素数（如果是就放入primeChan）
    for i:=0;i<4;i++{
        go putPrimeNum(intChan,primeChan,exitChan)
    }

    // 退出主线程之前，先判断exitChan管道内的值是否都会true
    go func(){
        for i:=0;i<4;i++{
            <-exitChan
        }
        // 如果从exitChan管道内取出了4个true，就可以退出主线程了
        close(primeChan)
    }()

    // 遍历primeChan，把值取出
    for{
        num,ok:=<-primeChan
        if !ok {
            break
        }
        fmt.Println("素数: ",num)
    }
    fmt.Println("主线程退出")
    // 返回值：
    // 素数:  。。。
    // 协程putPrimeNum取不到数据，退出
    // 协程putPrimeNum取不到数据，退出
    // 协程putPrimeNum取不到数据，退出
    // 协程putPrimeNum取不到数据，退出
    // 主线程退出
}

3.8、channel的使用细节和注意事项

1.channel可以定义为只读或者只写模式（应用场景：把一个可读可写的管道传入一个函数，函数内对管道做下封装，只允许读/写）

只读模式，只写模式的代码定义：

package main

import "fmt"

func main() {
    // 定义一个"只写"的管道
    var intChanWrite chan<- int
    intChanWrite = make(chan<- int,3)
    intChanWrite<-10
    // "只写"的管道的不能取数据
    // num:=<-intChan

    // 定义一个"只读"的管道
    var intChanRead <-chan int
    intChanRead = make(<-chan int,3)
    num:=<-intChanRead
    fmt.Println(num)  // 因为管道内没有数据，这里取不到值
    // "只读"的管道的不能写数据
    //intChanRead<-10
}

2.使用select可以解决从管道内取数据阻塞的问题

package main

import (
    "fmt"
)

func main() {
    // 定义管道并存放值
    intChan := make(chan int,10)
    for i:=0;i<10;i++{
        intChan<-i
    }
    stringChan := make(chan string,5)
    for i:=0;i<5;i++{
        stringChan<-"hello"+fmt.Sprintf("%d",i)
    }

    // 传统的方式在遍历管道时，如果不关闭管道会deadlock（阻塞）
    // 实际开发中，不好确认什么时候关闭管道，此时使用select（解决从管道内取数据时，阻塞的问题）
    for  {
        select {
        // 如果管道intChan没有关闭，同时又取不到值时，不会deadlock（阻塞）会去下一个case取值
        case v:= <-intChan:
            fmt.Println("从intChan管道内取到的值",v)
        // 如果管道stringChan没有关闭，同时又取不到值时，不会deadlock（阻塞）会去下一个case取值
        case v:= <-stringChan:
            fmt.Println("从stringChan管道内取到的值",v)
        // 默认逻辑
        default:
            fmt.Println("管道内取不到值了。。。")
            return
        }
    }
}

3.协程中使用recover，解决协程中出现panic，导致程序崩溃的问题

package main

import (
    "fmt"
    "time"
)

func test()  {
    // defer + recover 捕获当前函数抛出的panic错误
    defer func() {
        err:=recover()
        if err != nil {
            fmt.Println("test函数发生错误",err)
        }
    }()
    // 函数的代码逻辑（这里故意写的错误代码，触发报错）
    var testmap map[int]string
    testmap[0]="sudada"
}

func main() {
    go test()
    // 正常的代码执行（不加recover时，协程报错，整个程序就退出了。加上recover后，协程报错了不影响正常代码的执行）
    for  {
        fmt.Println("main")
        time.Sleep(time.Second)
    }
    // 返回值：
    // main
    // test函数发生错误 assignment to entry in nil map
    // main
}