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

发布时间:2024年01月06日

一、单元测试

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 -v cal_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 chan int (intChan用于存放int数据)

var?mapChan chan map[int]string?(mapChan用于存放map[int]string数据)

var?perChan chan Person?(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
}

文章来源:https://blog.csdn.net/sinat_29214327/article/details/135432477
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。