一、合理地使用并发特性
1、了解goroutine的生命期时再创建goroutine
代码如下:
package main
import (
"fmt"
"runtime"
)
//一段耗时的计算函数
func consumer(ch chan int) {
//无限获取数据的循环
for {
//从通道获取数据
data := <-ch
//打印数据
fmt.Println(data)
}
}
func main() {
//创建一个传递数据用的通道
ch := make(chan int)
for {
//空变量,什么也不做
var dummy string
//获取输入,模拟进程持续运行
fmt.Scan(&dummy)
//启动并发执行consumer()函数
go consumer(ch)
//输出现在的goroutine数量
fmt.Println("goroutines:", runtime.NumGoroutine())
}
}
运行结果如下:死循环
代码如下:
package main
import (
"fmt"
"runtime"
)
//一段耗时的计算函数
func consumer(ch chan int) {
//无限获取数据的循环
for {
//从通道获取数据
data := <-ch
if data == 0 {
break
}
//打印数据
fmt.Println(data)
}
}
func main() {
//创建一个传递数据用的通道
ch := make(chan int)
for {
//空变量,什么也不做
var dummy string
//获取输入,模拟进程持续运行
fmt.Scan(&dummy)
if dummy == "quit" {
for i := 0; i < runtime.NumGoroutine()-1; i++ {
ch <- 0
}
continue
}
//启动并发执行consumer()函数
go consumer(ch)
//输出现在的goroutine数量
fmt.Println("goroutines:", runtime.NumGoroutine())
}
}
运行结果如下:死循环
2、避免在不必要的地方使用通道
代码如下:
package main
import (
"fmt"
"net"
"time"
)
//套接字接收过程
func socketRecv(conn net.Conn, exitChan chan string) {
//创建一个接收的缓冲
buff := make([]byte, 1024)
//不停地接收数据
for {
//从套接字中读取数据
_, err := conn.Read(buff)
//需要结束接收,退出循环
if err != nil {
break
}
}
//函数已经结束,发送通知
exitChan <- "recv exit"
}
func main() {
//连接一个地址
conn, err := net.Dial("tcp", "www.163.com:80")
//发生错误时打印错误退出
if err != nil {
fmt.Println(err)
return
}
//创建退出通道
exit := make(chan string)
//并发执行套接字接收
go socketRecv(conn, exit)
//在接收时,等待1秒
time.Sleep(time.Second)
//主动关闭套接字
conn.Close()
//等待goroutine退出完毕
fmt.Println(<-exit)
}
运行结果如下:
recv exit
代码如下:
package main
import (
"fmt"
"net"
"sync"
"time"
)
//套接字接收过程
func socketRecv(conn net.Conn, wg *sync.WaitGroup) {
//创建一个接收的缓冲
buff := make([]byte, 1024)
//不停地接收数据
for {
//从套接字中读取数据
_, err := conn.Read(buff)
//需要结束接收,退出循环
if err != nil {
break
}
}
//函数已经结束,发送通知
wg.Done()
}
func main() {
//连接一个地址
conn, err := net.Dial("tcp", "www.163.com:80")
//发生错误时打印错误退出
if err != nil {
fmt.Println(err)
return
}
//退出通道
var wg sync.WaitGroup
//添加一个任务
wg.Add(1)
//并发执行接收套接字
go socketRecv(conn, &wg)
//在接收时,等待1秒
time.Sleep(time.Second)
//主动关闭套接字
conn.Close()
//等待goroutine退出完毕
wg.Wait()
fmt.Println("recv done")
}
运行结果如下:
recv done
二、反射:性能和灵活性的双刃剑
创建一个文件夹reflecttest,创建一个文件reflect_test.go。
代码如下:
package main
import (
"reflect"
"testing"
)
// 声明一个结构体,拥有1个字段
type data struct {
Hp int
}
func BenchmarkNativeAssign(b *testing.B) {
// 实例化结构体
v := data{Hp: 2}
// 停止基准测试的计时器
b.StopTimer()
// 重置基准测试计时器数据
b.ResetTimer()
// 重新启动基准测试计时器
b.StartTimer()
// 根据基准测试数据进行循环测试
for i := 0; i < b.N; i++ {
// 结构体成员赋值测试
v.Hp = 3
}
}
func BenchmarkReflectAssign(b *testing.B) {
v := data{Hp: 2}
// 取出结构体指针的反射值对象,并取其元素
vv := reflect.ValueOf(&v).Elem()
// 根据名字取结构体成员
f := vv.FieldByName("Hp")
b.StopTimer()
b.ResetTimer()
b.StartTimer()
for i := 0; i < b.N; i++ {
// 反射测试设置成员值性能
f.SetInt(3)
}
}
func BenchmarkReflectFindFieldAndAssign(b *testing.B) {
v := data{Hp: 2}
vv := reflect.ValueOf(&v).Elem()
b.StopTimer()
b.ResetTimer()
b.StartTimer()
for i := 0; i < b.N; i++ {
// 测试结构体成员的查找和设置成员的性能
vv.FieldByName("Hp").SetInt(3)
}
}
func foo(v int) {
}
func BenchmarkNativeCall(b *testing.B) {
for i := 0; i < b.N; i++ {
// 原生函数调用
foo(0)
}
}
func BenchmarkReflectCall(b *testing.B) {
// 取函数的反射值对象
v := reflect.ValueOf(foo)
b.StopTimer()
b.ResetTimer()
b.StartTimer()
for i := 0; i < b.N; i++ {
// 反射调用函数
v.Call([]reflect.Value{reflect.ValueOf(2)})
}
}
运行结果如下:
PS C:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\Go\reflecttest> go test -v -bench=.
testing: warning: no tests to run
PASS
ok _/C_/Users/a-xiaobodou/OneDrive_-_Microsoft/Projects/Go/reflecttest 0.326s [no tests to run]
PS C:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\Go\reflecttest>
三、接口的nil判断
四、map的多键索引——多个数值条件可以同时查询
五、优雅地处理TCP粘包