go常用工具（5）

一、获取环境变量

:::info 导入包：import os;

var goos string = os.Getenv("GOOS")

:::

二、产生随机数

:::info 导入包："math/rand"、 "time"包，import "math/rand";``import "time";

设置随机种子：rand.Seed(time.Now().Unix())

产生一个0到1000随机数：rand.Intn(1000)

:::

package main
import (
    "fmt"
    "math/rand"
    "time"
)
// 求元素和
func sumArr(a [10]int) int {
    var sum int = 0
    for i := 0; i < len(a); i++ {
        sum += a[i]
    }
    return sum
}
func main() {
    // 若想做一个真正的随机数，要种子
    // seed()种子默认是1
    //rand.Seed(1)
    rand.Seed(time.Now().Unix())
    var b [10]int
    for i := 0; i < len(b); i++ {
        // 产生一个0到1000随机数
        b[i] = rand.Intn(1000)
    }
    sum := sumArr(b)
    fmt.Printf("sum=%d\n", sum)
}

三、排序

:::color2 导入包：import "sort"

:::

:::info 基础类型排序**：**

sort函数：sort用于各种排序，这里仅列出sort中一些常用的函数方法：

sort.Sort()函数不能保证排序的稳定性。底层使用的是快排。

Ints、Float64s、Strings底层使用的是Sort()，所以他们三个也是不稳定的；

:::

package main
import (
    "fmt"
    "sort"
)
func main() {
    //整数排序
    a := []int{1,3,5,2,35}
    // 正序
    sort.Ints(a)
    fmt.Println("正序sort.Ints()：a=",a)
    sort.Sort(sort.IntSlice(a))
    fmt.Println("正序sort.Sort()：a=",a)
    // 逆序
    sort.Sort(sort.Reverse(sort.IntSlice(a)))
    fmt.Println("逆序：a=",a)
    //浮点数排序
    b := []float64{1.2,5.6,3.4,7.0,2.5}
    // 正序
    sort.Float64s(b)
    fmt.Println("正序sort.Float64s()：b=",b)
    sort.Sort(sort.Float64Slice(b))
    fmt.Println("正序sort.Sort()：b=",b)
    // 逆序
    sort.Sort(sort.Reverse(sort.Float64Slice(b)))
    fmt.Println("逆序：b=",b)
    //字符串排序
    c := []string{"aaa","dds","ccc","bbd"}
    // 正序
    sort.Strings(c)
    fmt.Println("正序sort.Strings()：c=",c)
    sort.Sort(sort.StringSlice(c))
    fmt.Println("正序sort.Sort()：c=",c)
    // 逆序
    sort.Sort(sort.Reverse(sort.StringSlice(c)))
    fmt.Println("逆序：c=",c)
}

:::info sort.Stable()函数能保证排序的稳定性。底层使用的是插入排序。

:::

package main
import (
    "fmt"
    "sort"
)
func main() {
    //整数排序
    a := []int{1,3,5,2,35}
    // 正序
    sort.Stable(sort.IntSlice(a))
    fmt.Println("正序sort.Stable()：a=",a)
    //浮点数排序
    b := []float64{1.2,5.6,3.4,7.0,2.5}
    sort.Stable(sort.Float64Slice(b))
    fmt.Println("正序sort.Stable()：b=",b)
    //字符串排序
    c := []string{"aaa","dds","ccc","bbd"}
    // 正序
    sort.Stable(sort.StringSlice(c))
    fmt.Println("正序sort.Stable()：c=",c)
}

:::warning 结构体类型排序：

Slice()是不稳定的，底层使用的是快排。

:::

package main
import (
    "fmt"
    "sort"
)
//定义一个结构体
type Student struct {
    Score int
    Name  string
}
func main() {
    x := []Student{ {2, "lcc"},{1, "ry"},{2, "yyr"}, {3, "lyh"}}
    sort.Slice(x, func(i, j int) bool {
        if x[i].Score != x[j].Score {
            return x[i].Score < x[j].Score
        } else {
            return x[i].Name < x[j].Name
        }
    })
    fmt.Println(x)
}

:::warning SliceStable()是稳定的，底层使用的是插入排序。

:::

package main
import (
    "fmt"
    "sort"
)
//定义一个结构体
type Student struct {
    Score int
    Name  string
}
func main() {
    x := []Student{ {2, "lcc"},{1, "ry"},{2, "yyr"}, {3, "lyh"}}
    sort.SliceStable(x, func(i, j int) bool {
        if x[i].Score != x[j].Score {
            return x[i].Score < x[j].Score
        } else {
            return x[i].Name < x[j].Name
        }
    })
    fmt.Println(x)
}

:::warning 判断是否有序：

sort.IsSorted()只能判断正序，尽管元素已经为逆序，也要经过sort.Reverse()处理一下，否则返回false。

:::

package main
import (
    "fmt"
    "sort"
)
func main() {
    //判断是否有序
    fmt.Println(sort.IsSorted(sort.IntSlice([]int{5,4,3,2})))    // fasle
    fmt.Println(sort.IsSorted(sort.Reverse(sort.IntSlice([]int{5,4,3,2}))))        //true
    fmt.Println(sort.IsSorted(sort.IntSlice([]int{1,2,4,5})))        //true
}

:::warning 查找元素**：**

Search函数采用二分法搜索找到[0, n)区间内最小的满足f(i)==true的值i，如果没有该值，函数会返回n。

常用的就是找元素插入位置：找到值x在插入一个有序的、可索引的数据结构时，应插入的位置。

SearchInts、SearchFloat64s、SearchStrings都是将Search封装了一层。

:::

package main
import (
    "fmt"
    "sort"
)
定义一个结构体
type Student struct {
    Score int
    Name  string
}
func main() {
    // 整数查找
    a := []int{1, 2, 3, 5, 35}
    fmt.Println(sort.SearchInts(a, 4)) //3
    // 浮点数查找
    b := []float64{1.2, 2.5, 3.4, 5.6, 7.0}
    fmt.Println(sort.SearchFloat64s(b, 3.0)) //2
    // 字符串查找
    c := []string{"aaa", "bbd", "ccc", "dds"}
    fmt.Println(sort.SearchStrings(c, "cac")) //2
    // 自定义查找——查找学生中score为2且名字为lca学生的插入位置
    x := []Student{{1, "ry"}, {2, "lcc"}, {2, "yyr"}, {3, "lyh"}}
    fmt.Println(sort.Search(len(x), func(i int) bool {
        return x[i].Score == 2 && x[i].Name >= "lca"
    })) //1
}

四、tag和json序列化和反序列化

:::color2 导入包：import "encoding/json"

:::

:::color1 结构体与JSON序列化：JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式，键/值对组合中的键名写在前面并用双引号””包裹，使用冒号:分隔，然后**紧接着值（不要有空格）；多个键值之间使用英文,分隔**。

:::

//Student 学生
type Student struct {
    ID     int
    Gender string
    Name   string
}
//Class 班级
type Class struct {
    Title    string
    Students []*Student
}
func main() {
    c := &Class{
        Title:    "101",
        Students: make([]*Student, 0, 200),
    }
    for i := 0; i < 10; i++ {
        stu := &Student{
            Name:   fmt.Sprintf("stu%02d", i),
            Gender: "男",
            ID:     i,
        }
        c.Students = append(c.Students, stu)
    }
    //JSON序列化：结构体-->JSON格式的字符串
    data, err := json.Marshal(c)
    if err != nil {
        fmt.Println("json marshal failed")
        return
    }
    fmt.Printf("json:%s\n", data)
    //JSON反序列化：JSON格式的字符串-->结构体
    str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
    c1 := &Class{}
    err = json.Unmarshal([]byte(str), c1)
    if err != nil {
        fmt.Println("json unmarshal failed!")
        return
    }
    fmt.Printf("%#v\n", c1)
}

:::color1 结构体标签（Tag）：Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来；Tag在结构体字段的后方定义，由一对反引号包裹起来，具体的格式如下：key1:"value1" key2:"value2"

tag及json序列化相关：

1. 结构体需要序列化的字段要大写，小写不被序列化；
2. 没有写tag的结构体成员只要首字母大写也可以序列化，json序列化是默认使用字段名作为key；
3. 结构体成员后面通过指定tag实现json序列化该字段时的key为tag里面的key（主要思想就是结构体中的成员首字母小写对外不可见，但是我们把成员定义为首字母大写这样与外界进行数据交互会带来极大的不便，此时tag带来了解决方法）

:::

//Student 学生
type Student struct {
    ID     int    `json:"id"` //通过指定tag实现json序列化该字段时的key
    Gender string //json序列化是默认使用字段名作为key
    name   string //私有不能被json包访问
}
func main() {
    s1 := Student{
        ID:     1,
        Gender: "女",
        name:   "pprof",
    }
    data, err := json.Marshal(s1)
    if err != nil {
        fmt.Println("json marshal failed!")
        return
    }
    fmt.Printf("json str:%s\n", data) //json str:{"id":1,"Gender":"女"}
}

五、加锁 & 线程安全的sync.Map

:::color2 导入包：import "sync"

:::

方式一：sync.Map

package main
import (
    "fmt"
    "sync"
)
func main() {
    var ma sync.Map// 该类型是开箱即用，只需要声明既可
    ma.Store("key", "value") // 存储值
    ma.Delete("key") //删除值
    ma.LoadOrStore("key", "value")// 获取值，如果没有则存储
    fmt.Println(ma.Load("key"))//获取值
    //遍历
    ma.Range(func(key, value interface{}) bool {
        fmt.Printf("key:%s ,value:%s \n", key, value)
        //如果返回：false，则退出循环，
        return true
    })
}

方式二：增加同步机制

package main
import (
    "sync"
)
func main() {
    // 通过匿名结构体声明了一个变量counter，变量中包含了map和sync.RWMutex
    var counter = struct{
        sync.RWMutex
        m map[string]int
    }{m: make(map[string]int)}
    // 读取数据的时候使用读锁
    counter.RLock()
    n := counter.m["Tony"]
    counter.RUnlock()
    // 写数据的使用使用写锁
    counter.Lock()
    counter.m["Tony"]++
    counter.Unlock()
}

六、runtime包

:::color2 导入包：import "runtime"

:::

:::warning **<font style="color:rgb(51, 51, 51);">runtime.Gosched()</font>**：让出CPU时间片，重新等待安排任务；

:::

package main
import (
    "fmt"
    "runtime"
)
func main() {
    go func(s string) {
        for i := 0; i < 2; i++ {
            fmt.Println(s)
        }
    }("world")
    // 主协程
    for i := 0; i < 2; i++ {
        // 切一下，再次分配任务
        runtime.Gosched()
        fmt.Println("hello")
    }
}
// 输出 
/*
world
world
hello
hello
*/

:::warning **<font style="color:rgb(51, 51, 51);">runtime.Goexit()</font>**：退出当前协程；

:::

package main
import (
    "fmt"
    "runtime"
)
func main() {
    go func() {
        defer fmt.Println("A.defer")
        func() {
            defer fmt.Println("B.defer")
            // 结束协程
            runtime.Goexit()
            defer fmt.Println("C.defer")
            fmt.Println("B")
        }()
        fmt.Println("A")
    }()
    for {
    }
}
// 输出 
/*
B.defer
A.defer
*/

:::warning **<font style="color:rgb(51, 51, 51);">runtime.GOMAXPROCS</font>**：Go运行时的调度器使用GOMAXPROCS参数来确定需要使用多少个OS线程来同时执行Go代码。默认值是机器上的CPU核心数。

:::

package main
import (
    "fmt"
    "runtime"
    "time"
)
func a() {
    for i := 1; i < 10; i++ {
        fmt.Println("A:", i)
    }
}
func b() {
    for i := 1; i < 10; i++ {
        fmt.Println("B:", i)
    }
}
func main() {
    runtime.GOMAXPROCS(1)
    go a()
    go b()
    time.Sleep(time.Second)
}

七、time包

:::color2 导入包：<font style="color:rgb(51, 51, 51);">import "time"</font>

time包：提供了时间的显示和测量用的函数。日历的计算采用的是公历。

:::

:::color2 时间类型（**time.Time**）：我们可以通过<font style="color:rgb(51, 51, 51);">time.Now()</font>函数获取当前的时间对象，然后获取时间对象的年月日时分秒等信息。

:::

:::color2 获取时间格式方法：

now := time.Now()：打印now：2023-04-08 10:56:45.6546694 +0800 CST m=+0.007066301

timestamp := now.Unix()：打印timestamp：1680922823

timestamp := now.UnixNano()：打印timestamp：1680922823775088700

timeObj := time.Unix(timestamp, 0)：打印timeObj：2023-04-08 11:09:00 +0800 CST

:::

package main
import (
    "fmt"
    "time"
)
func main() {
    now := time.Now() //获取当前时间
    fmt.Printf("current time:%T\n", now)        // current time:time.Time
    fmt.Printf("current time:%v\n", now)        // current time:2023-04-08 10:56:45.6546694 +0800 CST m=+0.007066301
    year := now.Year()     //年
    month := now.Month()   //月
    day := now.Day()       //日
    hour := now.Hour()     //小时
    minute := now.Minute() //分钟
    second := now.Second() //秒
    fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)  //2023-04-08 10:56:45
}

:::color2 时间戳：时间戳是自1970年1月1日（08:00:00GMT）至当前时间的总毫秒数。它也被称为Unix时间戳（UnixTimestamp）。

<font style="color:rgb(51, 51, 51);">time.Unix()</font>：函数可以将时间戳转为时间格式，

:::

func timestampDemo() {
    now := time.Now()            // 获取当前时间
    timestamp1 := now.Unix()     // 时间戳
    timestamp2 := now.UnixNano() // 纳秒时间戳
    fmt.Printf("current timestamp1:%v\n", timestamp1)  // current timestamp1:1680922823
    fmt.Printf("current timestamp2:%v\n", timestamp2)  // current timestamp2:1680922823775088700
}

package main
import (
    "fmt"
    "time"
)
func main() {
        now := time.Now()            //获取当前时间
        timestamp := now.Unix()     //时间戳
        timeObj := time.Unix(timestamp, 0) //将时间戳转为时间格式        //2023-04-08 11:09:00 +0800 CST
        fmt.Println(timeObj)
        year := timeObj.Year()     //年
        month := timeObj.Month()   //月
        day := timeObj.Day()       //日
        hour := timeObj.Hour()     //小时
        minute := timeObj.Minute() //分钟
        second := timeObj.Second() //秒
        fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second) // 2023-04-08 11:09:00
}

:::color2 时间间隔类型（**time.Duration**）：time.Duration是time包定义的一个类型，以纳秒为单位，time.Duration表示1纳秒，time.Second表示1秒；

:::

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

:::color2 时间操作：

Add：func (t Time) Add(d Duration) Time

Sub：求两个时间之间的差值func (t Time) Sub(u Time) Duration，返回一个时间段t-u

Equal：func (t Time) Equal(u Time) bool判断两个时间是否相同，会考虑时区的影响，因此不同时区标准的时间也可以正确比较；

Before：func (t Time) Before(u Time) bool如果t代表的时间点在u之前，返回真；否则返回假。

After：func (t Time) After(u Time) bool如果t代表的时间点在u之后，返回真；否则返回假。

:::

func main() {
    now := time.Now()
    later := now.Add(time.Hour) // 当前时间加1小时后的时间
    fmt.Println(later)
}

:::color2 定时器：使用<font style="color:rgb(51, 51, 51);">time.Tick(时间间隔)</font>来设置定时器，定时器的本质上是一个通道（channel）。

:::

func tickDemo() {
    ticker := time.Tick(time.Second) //定义一个1秒间隔的定时器
    for i := range ticker {
        fmt.Println(i)//每秒都会执行的任务
    }
}

:::color2 时间格式化：时间类型有一个自带的方法Format进行格式化，需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S，而是使用Go的诞生时间2006年1月2号15点04分（记忆口诀为2006 1 2 3 4）。也许这就是技术人员的浪漫吧。

补充：如果想格式化为12小时方式，需指定PM。

:::

now := time.Now()
// 格式化的模板为Go的出生时间2006年1月2号15点04分 Mon Jan
// 24小时制
fmt.Println(now.Format("2006-01-02 15:04:05.000 Mon Jan"))        // 2023-04-08 11:36:44.841 Sat Apr
// 12小时制
fmt.Println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan"))    // 2023-04-08 11:36:44.841 AM Sat Apr
fmt.Println(now.Format("2006/01/02 15:04"))                // 2023/04/08 11:36
fmt.Println(now.Format("15:04 2006/01/02"))                // 11:36 2023/04/08
fmt.Println(now.Format("2006/01/02"))                    // 2023/04/08

八、sync.WaitGroup

:::success 引包：import "sync"

需要注意sync.WaitGroup是一个结构体，传递的时候要传递指针。

:::

sync.WaitGroup内部维护着一个计数器，计数器的值可以增加和减少。例如当我们启动了N 个并发任务时，就将计数器值增加N。每个任务完成时通过调用Done()方法将计数器减1。通过调用Wait()来等待并发任务执行完，当计数器值为0时，表示所有并发任务已经完成。

var wg sync.WaitGroup
func hello() {
    defer wg.Done()
    fmt.Println("Hello Goroutine!")
}
func main() {
    wg.Add(1)
    go hello() // 启动另外一个goroutine去执行hello函数
    fmt.Println("main goroutine done!")
    wg.Wait()
}

九、sync.Once.Do

:::success 引包：import "sync"

**<font style="color:#DF2A3F;">sync.Once</font>**：只执行一次场景任务；在编程的很多场景下我们需要确保某些操作在高并发的场景下只执行一次，例如只加载一次配置文件、只关闭一次通道等。

<font style="color:rgb(51, 51, 51);">sync.Once</font>只有一个Do方法:func (o *Once) Do(f func()) {}

注意：如果要执行的函数f需要传递参数就需要搭配闭包来使用。

:::

package main
import (
    "fmt"
    "sync"
    "time"
)
var once sync.Once
func main() {
    for i, v := range make([]string, 10) {
        once.Do(onces)
        fmt.Println("count:", v, "---", i)
    }
    for i := 0; i < 5; i++ {
        go func() {
            once.Do(onced)
            fmt.Println("213")
        }()
    }
    time.Sleep(4000)
}
func onces() {
    fmt.Println("执行onces")
}
func onced() {
    fmt.Println("执行onced")
}
/*
PS go run .\3\3-6-once.go
执行onces
count:  --- 0
count:  --- 1
count:  --- 2
count:  --- 3
count:  --- 4
count:  --- 5
count:  --- 6
count:  --- 7
count:  --- 8
count:  --- 9
213
213
213
213
213
PS
*/

十、阻塞等待信号输入

:::success 导包：**import ****"os"** 、**import ****"os/signal"** 、**import ****"syscall"**

:::

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
)
//Ctrl +C 退出
sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
fmt.Printf("wait Ctrl +C\n")
fmt.Printf("quit (%v)\n", <-sig)   // 这里有缓冲管道阻塞

十一、互斥锁sync.Mutex

:::success 数据竞态：可能会存在多个goroutine同时操作一个资源（临界区），这种情况会发生竞态问题；

竞态检查工具**：是基于运行时代码检查，而不是通过代码静态分析来完成的。这意味着那些没有机会运行到的代码逻辑中如果存在安全隐患，它是检查不出来的。需要加上-race 执行**。go run <font style="color:#DF2A3F;">-race</font> 代码

:::

:::success 互斥锁（**sync.Mutex**）：互斥锁是一种常用的控制共享资源访问的方法，它能够保证同时只有一个goroutine可以访问共享资源。Go语言中使用sync包的Mutex类型来实现互斥锁。

:::

// 不加锁版本    输出6379
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() {
    wg.Add(2)
    go add()
    go add()
    wg.Wait()
    fmt.Println(x)
}
// 加锁版本  输出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() {
    wg.Add(2)
    go add()
    go add()
    wg.Wait()
    fmt.Println(x)
}

:::success 读写互斥锁：互斥锁是完全互斥的，但是有很多实际的场景下是读多写少的，当我们并发的去读取一个资源不涉及资源修改的时候是没有必要加锁的，这种场景下使用读写锁是更好的一种选择。读写锁在Go语言中使用sync包中的<font style="color:rgb(51, 51, 51);">RWMutex</font>类型。

读写锁优势：读写锁非常适合读多写少的场景，如果读和写的操作差别不大，读写锁的优势就发挥不出来。

:::

package main
import (
   "fmt"
   "time"
   "sync"
)
var (
    x      int64
    wg     sync.WaitGroup
    lock   sync.Mutex
    rwlock sync.RWMutex
)
func write() {
    lock.Lock()   // 加互斥锁
    // rwlock.Lock() // 加写锁
    x = x + 1
    time.Sleep(10 * time.Millisecond) // 假设写操作耗时10毫秒
    // rwlock.Unlock()                   // 解写锁
    lock.Unlock()                     // 解互斥锁
    wg.Done()
}
func read() {
    lock.Lock()                  // 加互斥锁
    // rwlock.RLock()               // 加读锁
    time.Sleep(time.Millisecond) // 假设读操作耗时1毫秒
    // rwlock.RUnlock()             // 解读锁
    lock.Unlock()                // 解互斥锁
    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.Println(end.Sub(start))
}
// 读写锁 146.8492ms
// 互斥锁 15.0116383s

:::success 避免锁复制：sync.Mutex是一个结构体对象，这个对象在使用的过程中要避免被复制 —— 浅拷贝。复制会导致锁被「分裂」了，也就起不到保护的作用。所以在平时的使用中要尽量使用它的指针类型。

锁复制存在于结构体变量的赋值、函数参数传递、方法参数传递中，都需要注意。

:::

package main
import (
    "fmt"
    "sync"
)
type SafeDict struct {
    data  map[string]int
    mutex *sync.Mutex
}
func NewSafeDict(data map[string]int) *SafeDict {
    return &SafeDict{
        data:  data,
        mutex: &sync.Mutex{},
    }
}
// defer 语句总是要推迟到函数尾部运行，所以如果函数逻辑运行时间比较长，
// 这会导致锁持有的时间较长，这时使用 defer 语句来释放锁未必是一个好注意。
func (d *SafeDict) Len() int {
    d.mutex.Lock()
    defer d.mutex.Unlock()
    return len(d.data)
}
// func (d *SafeDict) Test() int {
//     d.mutex.Lock()
//     length := len(d.data)
//     d.mutex.Unlock() // 手动解锁 减少粒度    // 这种情况就不要用 defer d.mutex.Unlock()
//     fmt.Println("length: ", length)
//     // 这里还有耗时处理 耗时1000ms
// }
func (d *SafeDict) Put(key string, value int) (int, bool) {
    d.mutex.Lock()
    defer d.mutex.Unlock()
    old_value, ok := d.data[key]
    d.data[key] = value
    return old_value, ok
}
func (d *SafeDict) Get(key string) (int, bool) {
    d.mutex.Lock()
    defer d.mutex.Unlock()
    old_value, ok := d.data[key]
    return old_value, ok
}
func (d *SafeDict) Delete(key string) (int, bool) {
    d.mutex.Lock()
    defer d.mutex.Unlock()
    old_value, ok := d.data[key]
    if ok {
        delete(d.data, key)
    }
    return old_value, ok
}
func write(d *SafeDict) {
    d.Put("banana", 5)
}
func read(d *SafeDict) {
    fmt.Println(d.Get("banana"))
}
// go run -race 3-2-lock.go
func main() {
    d := NewSafeDict(map[string]int{
        "apple": 2,
        "pear":  3,
    })
    go read(d)
    write(d)
}

:::info 匿名锁字段：在结构体章节，我们知道外部结构体可以自动继承匿名内部结构体的所有方法。如果将上面的SafeDict 结构体进行改造，将锁字段匿名，就可以稍微简化一下代码。

:::

package main
import (
    "fmt"
    "sync"
)
type SafeDict struct {
    data map[string]int
    *sync.Mutex
}
func NewSafeDict(data map[string]int) *SafeDict {
    return &SafeDict{
        data,
        &sync.Mutex{}, // 一样是要初始化的
    }
}
func (d *SafeDict) Len() int {
    d.Lock()
    defer d.Unlock()
    return len(d.data)
}
func (d *SafeDict) Put(key string, value int) (int, bool) {
    d.Lock()
    defer d.Unlock()
    old_value, ok := d.data[key]
    d.data[key] = value
    return old_value, ok
}
func (d *SafeDict) Get(key string) (int, bool) {
    d.Lock()
    defer d.Unlock()
    old_value, ok := d.data[key]
    return old_value, ok
}
func (d *SafeDict) Delete(key string) (int, bool) {
    d.Lock()
    defer d.Unlock()
    old_value, ok := d.data[key]
    if ok {
        delete(d.data, key)
    }
    return old_value, ok
}
func write(d *SafeDict) {
    d.Put("banana", 5)
}
func read(d *SafeDict) {
    fmt.Println(d.Get("banana"))
}
func main() {
    d := NewSafeDict(map[string]int{
        "apple": 2,
        "pear":  3,
    })
    go read(d)
    write(d)
}

十二、配置文件解析器goconfig

:::color2 导包：**"github.com/Unknwon/goconfig"**

section（段）：[]括起来的部分是段的概念，没有在某个显式段下的为default section。

:::

:::color2 API：

**<font style="color:#DF2A3F;">cfg</font>****, err := goconfig.LoadConfigFile("./conf.ini")**：加载配置文件，读取后文件就关闭了；

**cfg.GetValue(section, 字段)**：获取配置文件的string类型值，参1是section，参2是section中某个字段名；

section ： ""，代表默认段，或者使用常量**goconfig.DEFAULT_SECTION**；

**cfg.MustInt(section, 字段)**：获取配置文件的int类型值，带有Must的方法返回中无err；

**cfg.SetValue(section, 字段, 新值)**：**修改**字段值，修改的是内部的变量值，不会修改真实的配置文件；

**cfg.DeleteKey("", "MAX_PRICE")**：**删除**字段值，删除的是内部的变量值，不会修改真实的配置文件；

**cfg.AppendFiles("conf1.ini")**：将更多文件追加到ConfigFile并自动加载，不会修改真实的配置文件；

:::

;redis cache
USER_LIST = USER:LIST
MAX_COUNT = 50
MAX_PRICE = 123456
IS_SHOW = true
[test]
dbdns = root:@tcp(127.0.0.1:3306)
[prod]
dbdns = root:@tcp(172.168.1.1:3306)

package main
import (
    "fmt"
    "log"
    "github.com/Unknwon/goconfig"
)
func main() {
    cfg, err := goconfig.LoadConfigFile("./conf.ini")    // 读取后文件关闭了
    if err != nil {
        log.Fatalf("无法加载配置文件：%s", err)
    }
    userListKey, err := cfg.GetValue("", "USER_LIST")
    if err != nil {
        fmt.Println(err.Error())
    }
    fmt.Println(userListKey)
    userListKey2, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "USER_LIST")
    fmt.Println(userListKey2)
    maxCount := cfg.MustInt("", "MAX_COUNT")
    fmt.Println(maxCount)
    maxPrice := cfg.MustFloat64("", "MAX_PRICE")
    fmt.Println(maxPrice)
    isShow := cfg.MustBool("", "IS_SHOW")
    fmt.Println(isShow)
    db := cfg.MustValue("test", "dbdns")
    fmt.Println(db)
    dbProd := cfg.MustValue("prod", "dbdns")
    fmt.Println("dbProd: ",dbProd)
    //set 值
    cfg.SetValue("", "MAX_NEW", "100")
    maxNew := cfg.MustInt("", "MAX_NEW")
    fmt.Println(maxNew)
    maxNew1, err := cfg.Int("", "MAX_NEW")
    if err != nil {
        fmt.Println(err.Error())
    }
    fmt.Println(maxNew1)
    cfg.AppendFiles("conf1.ini")
    cfg.DeleteKey("", "MAX_PRICE")
    dbProd = cfg.MustValue("prod1", "dbdns")
    fmt.Println(dbProd)
}

十三、命令行解析器flag

:::color2 导包：**"flag"**：****

**cmd -flag** // 只支持bool类型

**cmd -flag=xxx** // 都支持

**cmd -flag xxx** // 只支持非bool类型

定义flag参数：

参数有三个：第一个为 参数名称，第二个为 默认值，第三个是 使用说明

（1）获取参数：通过 **flag.String()，Bool()，Int()** 等 **<font style="color:#DF2A3F;">flag.Xxx()</font>** 方法，该种方式返回一个相应的指针var ip = flag.Int("flagname", 1234, "help message for flagname")

（2）获取参数：通过** flag.XxxVar() **方法将 flag 绑定到一个变量，该种方式返回 值类型 var flagvar int flag.IntVar(&flagvar, "flagname", 1234, "help message for flagname")

（3）通过 **flag.Var()** 绑定自定义类型，自定义类型需要实现 Value 接口 (Receiver 必须为指针)

fmt.Println("flagvar has value ", flagvar)

flag参数列表中参数解析完arg中就没有了

:::

package main
import (
    "flag"
    "fmt"
    "os"
)
// go run 4-1-cli-flag.go -ok -id 11111 -port 8899 -name TestUser very goo
func main() {
    fmt.Println(os.Args)
    ok := flag.Bool("ok", false, "is ok") // 不设置ok 则为false
    id := flag.Int("id", 0, "id")
    port := flag.String("port", ":8080", "http listen port")
    var name string
    flag.StringVar(&name, "name", "Jack", "name")
    flag.Parse()
    //flag.Usage()
    others := flag.Args()
    fmt.Println("ok:", *ok)
    fmt.Println("id:", *id)
    fmt.Println("port:", *port)
    fmt.Println("name:", name)
    fmt.Println("other:", others)
}
/*    执行 go run 4-1-cli-flag.go -ok -id 11111 -port 8899 -name TestUser very goo
[C:\Users\Yi315\AppData\Local\Temp\go-build4257362743\b001\exe\5-1-cli-flag.exe -ok=true -id 11111 -port 8899 -name TestUser very goo]
ok: true
id: 11111
port: 8899
name: TestUser
other: [very goo]
*/

package main
import (
    "flag"
    "fmt"
)
type FlagSet struct {
    Usage func()
}
var myFlagSet = flag.NewFlagSet("myflagset", flag.ExitOnError)
var stringFlag = myFlagSet.String("abc", "default value", "help mesage")
func main() {
    myFlagSet.Parse([]string{"-abc", "def", "ghi", "123"})
    args := myFlagSet.Args()
    for i := range args {
        fmt.Println(i, myFlagSet.Arg(i))
    }
}

十四、临时对象池

:::color2 引包：**import "sync"**

**sync.Pool**类型值作为存放临时值的容器。此类容器是自动伸缩的，高效的，同时也是并发安全的。

**sync.Pool类型**只有两个方法：

◼ Put，用于在当前的池中存放临时对象，它接受一个空接口类型的值

◼ Get，用于从当前的池中获取临时对象，它返回一个空接口类型的值

New字段**：sync.Pool类型的New字段是一个创建临时对象的函数。它的类型是没有参数但是会返回一个空接口类型的函数。即：func() interface{}。这个函数是Get方法最后的获取到临时对象的手段。函数的结果不会被存入当前的临时对象池中，而是直接返回给Get方法的调用方。这里的New字段的实际值需要在初始化临时对象池的时候就给定**。否则，在Get方法调用它的时候就会得到nil。

:::

type Pool struct {
    noCopy noCopy
    local     unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocal
    localSize uintptr        // size of the local array
    victim     unsafe.Pointer // local from previous cycle
    victimSize uintptr        // size of victims array
    // New optionally specifies a function to generate
    // a value when Get would otherwise return nil.
    // It may not be changed concurrently with calls to Get.
    New func() any
}

:::color2 Get：

Pool 会为每个 P 维护一个本地池，P 的本地池分为 **私有池 private和共享池 shared。私有池中的元素只能本地 P 使用，共享池中的元素可能会被其他 P 偷走，所以使用私有池 private时不用加锁，而使用共享池 shared 时需加锁**。

**Get** 会优先查找本地 private，再查找本地 shared，最后查找其他 P 的shared，如果以上全部没有可用元素，最后会调用 New 函数获取新元素。

从临时对象池中取出的对象，一般都要做一个reset操作。

:::

:::color2 Put：

Put 优先把元素放在 private 池中；如果 private 不为空，则放在 shared 池中。有趣的是，在入池之前，该元素有 1/4 可能被丢掉。

:::

// Get selects an arbitrary item from the Pool, removes it from the
// Pool, and returns it to the caller.
// Get may choose to ignore the pool and treat it as empty.
// Callers should not assume any relation between values passed to Put and
// the values returned by Get.
//
// If Get would otherwise return nil and p.New is non-nil, Get returns
// the result of calling p.New.
func (p *Pool) Get() any {
    if race.Enabled {
        race.Disable()
    }
    l, pid := p.pin()
    x := l.private
    l.private = nil
    if x == nil {
        // Try to pop the head of the local shard. We prefer
        // the head over the tail for temporal locality of
        // reuse.
        x, _ = l.shared.popHead()
        if x == nil {
            x = p.getSlow(pid)
        }
    }
    runtime_procUnpin()
    if race.Enabled {
        race.Enable()
        if x != nil {
            race.Acquire(poolRaceAddr(x))
        }
    }
    if x == nil && p.New != nil {
        x = p.New()
    }
    return x
}
// Put adds x to the pool.
func (p *Pool) Put(x any) {
    if x == nil {
        return
    }
    if race.Enabled {
        if fastrandn(4) == 0 {
            // Randomly drop x on floor.
            return
        }
        race.ReleaseMerge(poolRaceAddr(x))
        race.Disable()
    }
    l, _ := p.pin()
    if l.private == nil {
        l.private = x
    } else {
        l.shared.pushHead(x)
    }
    runtime_procUnpin()
    if race.Enabled {
        race.Enable()
    }
}

package main
import (
    "bytes"
    "fmt"
    "io"
    "sync"
)
// 存放数据块缓冲区的临时对象
var bufPool sync.Pool
// 预定义定界符
const delimiter = '\n'
// 一个简易的数据库缓冲区的接口
type Buffer interface {
    Delimiter() byte                    // 获取数据块之间的定界符
    Write(contents string) (err error)  // 写入一个数据块
    Read() (contents string, err error) // 读取一个数据块
    Free()                              // 释放当前的缓冲区
}
// 实现一个上面定义的接口
type myBuffer struct {
    buf       bytes.Buffer
    delimiter byte
}
func (b *myBuffer) Delimiter() byte {
    return b.delimiter
}
func (b *myBuffer) Write(contents string) (err error) {
    if _, err = b.buf.WriteString(contents); err != nil {
        return
    }
    return b.buf.WriteByte(b.delimiter)
}
func (b *myBuffer) Read() (contents string, err error) {
    return b.buf.ReadString(b.delimiter)
}
func (b *myBuffer) Free() {
    bufPool.Put(b)
}
func init() {
    bufPool = sync.Pool{
        New: func() interface{} {
            return &myBuffer{delimiter: delimiter}
        },
    }
}
// 获取一个数据库缓冲区
func GetBuffer() Buffer {
    return bufPool.Get().(Buffer) // 做类型转换
}
func main() {
    buf := GetBuffer()
    defer buf.Free()
    buf.Write("写入第一行，")    // 写入数据
    buf.Write("接着写第二行。")    // 写入数据
    fmt.Println("数据已经写入，准备把数据读出")
    for {
        block, err := buf.Read()
        if err != nil {
            if err == io.EOF {
                break
            }
            panic(fmt.Errorf("读取缓冲区时ERROR: %s", err))
        }
        fmt.Print(block)
    }
}

:::color2 临时对象池的一个应用场景：

• 收到http请求，创建一个parser可以使用临时对象池
  • http是短连接
  • 总创建parser也很耗时，这时就可以引入对象池来提高效率
• 返回response时，也可以使用对象池，重新装配

:::