Go语言进阶笔记

课程地址：Go语言从入门到实践

基础部分

学习这个课程主要是对之前学习的查漏补缺，快速地过一遍。

课程中老师提到的一些概念

他们会大量的使用共享内存的方式，来进行并发控制，而忽略了 Go 语言本身内置的 CSP 的并发机制。

什么是CSP？

其实 Java 程序员在编写程序的时候，在方法调用间，传递数组参数时，通常是直接传递数组，导致大量的内存复制。与Java不同，Go的数组参数是通过值复制来进行传递的。

另外，Java程序员也总是喜欢创建一个只有接口定义的包，用于处理依赖关系，而其实这在 Go 中是大可不必的，因为Go中接口的实现与接口的定义是没有依赖关系的。

软件开发的新挑战

1. 多核硬件架构

2. 超大规模分布式计算集群

3. Web 模式导致的前所未有的开发规模和更新速度

开发环境构建

GOPATH

1. 在1.8版本前必须设置这个环境变量
2. 1.8版本后(含1.8)如果没有设置使用默认值 在Unix 上默认为 $HOME/go，在 Windows 上默认为 %USERPROFILE%/go 在Mac上GOPATH可以通过修改 ~/.bash_profile 来设置

返回程序退出时的状态

Go语言中，main()函数是不支持返回值的。可以使用os.Exit() 指定程序退出状态。

1

os.Exit(-1) // 指定程序退出状态

变量

变量声明和初始化

值类型：基本数据类型（如整数、浮点数、布尔值、字符串）、数组和结构体。 指针类型：切片、映射（map）、通道（channel）、指针、接口等。 如要对一个变量赋值，这个变量必须有对应分配好的内存这样才可以对这块内存操作，完成赋值的目的。 在声明时，如果是值类型，Go语言会帮我们分配内存，可以直接赋值使用。但如果是指针类型，我们就必须手动地申请开辟内存。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

func main() {
    var str string // 这里只声明了str变量，但由于string是值类型，所以系统会帮我们分配内存，所以下面可以直接赋值使用，而不用手动的开辟内存
    str = "hello"
    fmt.Println(str)

    var slice01 []int
    fmt.Println(len(slice01), cap(slice01)) // 0 0
    // 没有为slice01分配内存，直接使用是会报错的
    //slice01[0] = 1 // panic: runtime error: index out of range [0] with length 0
    //fmt.Println(slice01)

    // new()函数：根据传入的类型，申请一块内存，然后返回指向这块内存的指针。指针指向的数据就是该类型的零值。
    var slice02 = new([]int)
    fmt.Println(len(*slice02), cap(*slice02)) // 0 0
    fmt.Println(*slice02)                     // []

    // make函数只用于slice、chan和map 这三种内置类型的创建和初始化，因为这三种类型的结构比较复杂
    var slice03 = make([]int, 1)
    fmt.Println(slice03) // [0]
}

new用于基本数据类型和结构体类型的创建，返回一个指向新分配内存的指针，指针指向的数据就是该类型的零值。

make用于引用数据类型（如切片、映射、通道）的创建，返回一个已初始化的引用类型。

变量赋值

与其他主要编程语言的差异

• 赋值可以进行自动类型推断
• 在一个赋值语句中可以对多个变量进行同时赋值

可以使用a, b = b, a来交换两个变量的值。

常量定义

快速设置连续值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 连续的递增操作
const (
	Sunday    = iota + 1 // 1
	Monday               // 2
	Tuesday              // 3
	Wednesday            // ...
	Thursday
	Friday
	Saturday
)

// 连续的位移操作
const (
	Open    = 1 << iota // 1
	Close               // 2
	Pending             // 4
)

2023.10.05

类型转化

与其他主要编程语言的差异

1. Go 语言不允许隐式类型转换

2. 别名和原有类型也不能进行隐式类型转换

类型的预定义值

1. math.MaxInt64

2. math.MaxFloat64

3. math.MaxUint32

指针类型

与其他主要编程语言的差异

1. 不支持指针运算

在支持指针运算的语言中，可以通过指针的自增来获取连续的数组值，但是在go语言中是不支持指针的运算的。如：

1 2 3 4

a := 10 aPtr := &a //aPtr = aPtr + 1 // invalid operation: aPtr + 1 (mismatched types *int and untyped int) fmt.Println(a, aPtr)

2. string 是值类型，其默认的初始化值为空字符串，而不是 nil

1
2
3
4
5
6

var str string
if str == "" {
    fmt.Println("str==\"\"")  // 输出：str==""
} else {
    fmt.Println("str!=\"\"")
}

空结构体

(2023.10.11补)

在Go语言中，空结构体（empty struct）是一种特殊的数据结构，它不包含任何字段。它通常被用来实现某些特定的编程模式和技巧，有以下几个主要用途：

1. 占位符：空结构体可以用作占位符，占据内存空间但不包含任何有用的数据。这在某些情况下可以用于构建数据结构，例如在通道的元素中使用空结构体来表示事件的发生。

2. 同步锁：空结构体通常用于创建互斥锁或信号量。通过通道和空结构体的结合，你可以实现简单而高效的同步机制。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   var mu sync.Mutex var wg sync.WaitGroup ch := make(chan struct{}) // 锁定 mu.Lock() // 解锁 mu.Unlock() // 等待完成 wg.Wait() // 发信号 close(ch)

3. 实现集合：空结构体可以用来创建一个集合，它表示存在或者不在集合中的状态，而不需要存储任何额外的信息。

   1 2 3 4 5 6 7 8 9

   set := make(map[string]struct{}) // 添加元素 set["item1"] = struct{}{} // 检查元素是否存在 if _, exists := set["item1"]; exists { fmt.Println("元素存在") }

4. 简化接口：在某些情况下，接口的实现可能不需要存储额外的数据，只需实现接口的方法。此时，可以使用空结构体来实现这些接口，以减少内存开销。

总之，空结构体在Go语言中用于一些特定的编程技巧和模式，通常与通道、互斥锁、集合和接口实现相关。通过它们，可以更加灵活地构建高效的数据结构和同步机制，同时减少内存开销。

运算符

算术运算符

Go 语言没有前置的 ++，–。如：++a，--a是不被允许的。

用==比较数组

• 相同维数且含有相同个数元素的数组才可以比较

  如果维度不同，则编译直接报错。如下：

  1 2 3 4

  a := [2]int{1, 2} b := [3]int{1, 2, 3} isEqual := a == b // invalid operation: a == b (mismatched types [2]int and [3]int) fmt.Println(isEqual)

• 每个元素都相同的才相等

位运算符

与其他主要编程语言的差异

&^按位置零

1
2
3
4

1 &^ 0 --- 1
1 &^ 1 --- 0
0 &^ 1 --- 0
0 &^ 0 --- 0

如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main

import "fmt"

const (
    Readable = 1 << iota
    Writable
    Executable
)

func main() {
    a := 7 // 0111
    fmt.Println(a&Readable == Readable,
       a&Writable == Writable,
       a&Executable == Executable) // true true true

    // 现在使用 &^ 按位清零
    a = a &^ Readable // 将最低位 置0
    a = a &^ Writable // 将倒数第二位 置0
    fmt.Println(a&Readable == Readable,
       a&Writable == Writable,
       a&Executable == Executable) // false false true
}

函数是一等公民

与其他主要编程语言的差异

1. 可以有多个返回值

2. 所有参数都是值传递。slice，map，channel 会有传引用的错觉

3. 函数可以作为变量的值

4. 函数可以作为参数和返回值

函数式编程

面向对象

实例创建及初始化

1
2
3
4
5
6

e := Employee{"0", "Bob", 20}
e1 := Employee{Name:"Mike", Age: 30}
e2 := new(Employee)  //注意这里返回的引用/指针，相当于 e := &Employee{}
e2.Id ="2"  //与其他主要编程语言的差异: 通过实例的指针访问成员不需要使用->
e2.Age = 22
e2.Name ="Rose"

行为(方法)定义

与其他主要编程语言的差异

1
2
3
4
5

type Employee struct {
	Id string
	Name string
	Age int
}

1
2
3
4
5
6
7
8
9

//第一种定义方式在实例对应方法被调用时，实例的成员会进行值复制
func (e Employee) String() string {
    return fmt.Sprintf("ID:%s-Name:%s-Age:%d", e.Id, e.Name, e.Age)
}

//通常情况下为了避免内存拷贝我们使用第二种定义方式
func (e *Employee) String() string {
	return fmt.Sprintf("ID:%s/Name:%s/Age:%d", e.Id, e.Name, e.Age)
}

Go 接口

与其他主要编程语言的差异

1. 接口为非入侵性，实现不依赖于接口定义

2. 所以接口的定义可以包含在接口使用者包内

Go的错误机制

与其他主要编程语言的差异

1. 没有异常机制

2. error 类型实现了 error 接口

   1 2 3

   type error interface { Error() string }

3. 可以通过errors.New 来快速创建错误实例errors.New("n must be in the range [0,10]")

panic VS OS.Exit

os.Exit 退出时不会调用 defer 指定的函数 os.Exit 退出时不输出当前调用栈信息

init 方法

在main 被执行前，所有依赖的 package的init 方法都会被执行。 不同包的 init 函数按照包导入的依赖关系决定执行顺序。 每个包可以有多个 init 函数。 包的每个源文件也可以有多个 init 函数，这点比较特殊。

package

1. 通过 go get 来获取远程依赖

• go get -u 强制从网络更新远程依赖

2. 注意代码在 GitHub 上的组织形式，以适应 go get

• 直接以代码路径开始，不要有 src

示例: https://github.com/easierway/concurrent_map

Thead vs.Groutine

1. 创建时默认的 stack 的大小

• JDK5 以后 Java Thread stack 默认为1M

• Groutine 的 Stack 初始化大小为2K

2. 和KSE (Kernel Space Entity) 的对应关系

• Java Thread 是1:1
• Groutine 是M:N

结构体嵌套

非匿名嵌套

这种方式就是在结构体中嵌套另外一个结构体的变量。相当于新的结构体在原结构体的基础上进行扩展。 但这和java中的继承是完全不同的。 以这里为例，Gog1结构体中嵌套了Pet1结构体的变量。在Gog1的实例对象访问Pet1结构体的SpeakTo()方法时，必须使用Dog1.p.SpeakTo()来进行调用，而不能直接使用Dog1.SpeakTo()。 如果希望新的结构体中有和原结构体相同的方法，则需要重新实现相关的方法。但本质上来说，这Pet1的SpeakTo()方法和Dog1的SpeakTo()方法并没有任何的关系，也不存在类似于Java中的重写的功能。它们本质上就是两个彼此独立的方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

type Pet1 struct {}

func (p *Pet1) Speak() {
    fmt.Printf("...")
}

func (p *Pet1) SpeakTo(host string) {
    p.Speak()
    fmt.Println(" ", host)
}

type Dog1 struct {
    p *Pet1
}

// Speak 结构体Dog1重新实现Speak方法
func (d *Dog1) Speak() {
    d.p.Speak()
}

func (d *Dog1) SpeakTo(host string) {
    d.p.SpeakTo(host)
}
func main() {
    dog1 := &Dog1{}
    dog1.p.SpeakTo("Pet1") // 调用Pet1结构体的SpeakTo()方法
    dog1.SpeakTo("Gog1")   // 调用Dog1结构体的SpeakTo()方法
}

匿名嵌套

匿名嵌套的方式，可以使新的结构体Dog直接拥有原结构体Pet的所有属性和方法。Dog的对象dog可以直接访问Pet的方法。 分下面两种情况：

1. 如果Dog没有SpeakTo()方法：Dog.SpeakTo()，会直接调用结构体Pet的这个方法。

2. 如果Dog有SpeakTo()方法：Dog.SpeakTo()，会直接调用结构体Dog自身的这个方法。（和Java中重写的功能相同）

这样就好像在Go语言中实现了Java中的继承，但其实还是和Java是不相同的。 如下面的例子中，Dog结构体重写了Pet结构体的Speak()方法，现在Dog结构体的对象dog来调用SpeakTo()方法，在此方法中，又调用了Speak()方法。 现在，结构体Dog和Pet中都有Speak()方法，那么程序会调用哪一个Speak()方法呢？这里就体现出Java和Go的区别了。 Java：由于Dog继承自Pet，而Dog中又实现了Speak()方法，所以在SpeakTo()方法中调用Speak()方法时，会调用子类Dog中的此方法。 Go：由于Go语言没有继承，只有结构体的嵌套，现在虽然是结构体Dog的对象dog来调用SpeakTo()方法，但由于结构体Dog没有此方法，所以会去结构体Pet中调用SpeakTo()方法，在此方法中调用Speak()方法时，自然也是调用的结构体Pet中的Speak()方法，而不是结构体Dog中的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

type Pet struct {}

func (p *Pet) Speak() {
    fmt.Printf("...")
}

func (p *Pet) SpeakTo(host string) {
    p.Speak()
    fmt.Println(" ", host)
}

type Dog struct {
    Pet
}

// Speak 结构体Dog重新实现Speak方法
func (d *Dog) Speak() {
    fmt.Printf("wang...")
}

//  func (d *Dog) SpeakTo(host string) {
//     d.Speak()
//     fmt.Println(" ", host)
//  }
func main() {
    //var Dog *Dog = new(Dog)
    //var p = (*Pet)(Dog) // cannot convert Dog (variable of type *Dog) to type *Pet
    //p.SpeakTo("Pet")

    dog := new(Dog)
    dog.SpeakTo("Dog") // ...  Dog（调用的是Pet中的SpeakTo()方法）
}

总结

• 非匿名嵌套的方式，程序不会去找嵌套结构体中的方法，如果需要访问，需要程序员手动指定。

• 匿名嵌套的方式，程序会先找结构体自身是否有指定调用的方法，如果没有，再去找其嵌套的结构体中是否有对应的方法。如果嵌套结构体中的方法中又调用了其他方法，则程序也只会在嵌套的结构体中查找是否有该方法，而不会退出嵌套结构体进行查找。（只支持向内查找，不支持向外查找）

并发编程

介绍

Go 语言在语言级别内置了强大的并发支持，使得并发编程变得相对容易和高效。Go 语言的并发编程特性主要基于 goroutine 和 channel。以下是 Go 语言中的并发编程的核心概念和技术：

1. Goroutine：
   • Goroutine 是 Go 语言中的轻量级线程，由 Go 运行时系统管理。
   • 你可以通过使用关键字 go 来创建一个新的 goroutine，它会在一个独立的执行线程中运行。
   • Goroutine 之间的切换由 Go 运行时自动处理，而不需要显式的线程管理。

1
2
3
4
5
6
7
8

func main() {
    go doSomething() // 创建并启动一个新的 goroutine
    // 主 goroutine 继续执行其他操作
}

func doSomething() {
    // 在新的 goroutine 中执行的任务
}

2. Channel：
   • Channel 是 Go 语言用于在 goroutine 之间进行通信和同步的机制。
   • 通过 channel，你可以发送和接收数据，以协调多个 goroutine 之间的工作。
   • 使用 make 函数创建 channel，可以指定 channel 的类型。

1
2
3
4
5
6
7

ch := make(chan int) // 创建一个整数类型的 channel

go func() {
    ch <- 42 // 将数据发送到 channel
}()

value := <-ch // 从 channel 接收数据

3. 同步和等待：
   • 使用 sync 包中的工具，如 sync.WaitGroup 来等待 goroutine 完成。
   • sync.Mutex 和 sync.RWMutex 用于实现互斥锁，保护共享数据。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import (
    "sync"
)

func main() {
    var wg sync.WaitGroup

    // 启动多个 goroutine
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            // 在这里执行一些工作
        }(i)
    }

    // 等待所有 goroutine 完成
    wg.Wait()
}

4. Select 语句：
   • select 语句用于在多个 channel 操作中进行选择，使得你可以实现非阻塞的通信和超时等功能。
   • select 语句允许你在多个通信操作之间选择一个可用的操作执行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

select {
case msg1 := <-ch1:
    // 处理 ch1 中的消息
case msg2 := <-ch2:
    // 处理 ch2 中的消息
case ch3 <- data:
    // 发送数据到 ch3
default:
    // 当没有通信操作可用时执行的默认操作
}

5. 原子操作：
   • Go 语言提供了 sync/atomic 包，用于执行原子操作，以确保对共享变量的操作是线程安全的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import (
    "sync/atomic"
)

var counter int32

func increment() {
    atomic.AddInt32(&counter, 1)
}

func main() {
    // 启动多个 goroutine 并并发增加计数器
}

Go 语言的并发模型通过 goroutine 和 channel 简化了并发编程，使得编写安全且高效的并发代码变得容易。然而，正确地管理并发程序仍然需要小心谨慎，以避免竞态条件和死锁等问题。

提前退出Goroutine

我们可以使用runtime.Goexit()来退出当前的Goroutine。

• return：返回当前函数。
• os.Exit(-1)：退出进程。
• runtime.Goexit()：退出当前Goroutine。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func main() {
    go func() {
       func() {
          fmt.Println("这是子Goroutine内部的函数！")
          runtime.Goexit() // 当前协程直接结束，后面的输出语句不会执行
       }()
       fmt.Println("子Goroutine结束！")
    }()

    fmt.Println("这是主Goroutine！")
    time.Sleep(time.Second)
    fmt.Println("OVER!")
}

单例模式

使用once.Do()控制函数只执行一次。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

type Singleton struct {}

var singleInstance *Singleton
var once sync.Once

func GetSingletonObj() *Singleton {
    once.Do(func() { // 只执行一次
       fmt.Println("Create Obj")
       singleInstance = new(Singleton)
    })
    return singleInstance
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
       wg.Add(1)
       go func() {
          obj := GetSingletonObj()
          fmt.Printf("%x\n", unsafe.Pointer(obj)) // 可以看到，这里打印的地址值是相同的，说明只创建了一个实例对象。
          wg.Done()
       }()
    }
    wg.Wait()
}

任意一个任务完成

只要任意一个协程完成了任务，就直接返回，其他协程不再继续运行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

var numOfRunner = 10

func main() {
    fmt.Println("Number of Goroutine:", runtime.NumGoroutine()) // 查看当前运行的协程数量
    r := FirstResponse()
    fmt.Println(r)
    fmt.Println("Number of Goroutine:", runtime.NumGoroutine()) // 改成带缓冲的管道之后，多个协程被阻塞的问题被解决。
}

func runTask(id int) string {
    time.Sleep(10 * time.Millisecond)
    return fmt.Sprintf("This result is from %d", id)
}

func FirstResponse() string {
    ch := make(chan string, numOfRunner) // 3.解决办法：使用带缓冲的管道，其容量等于numOfRunner，这样就不会造成其他协程的阻塞。
    for i := 0; i < numOfRunner; i++ {
       go func(i int) {
          ret := runTask(i)
          ch <- ret // 2.但这样会造成一个问题，就是其余协程被阻塞在此，导致内存泄漏。
       }(i)
    }
    return <-ch // 1.只要ch中能够读出数据，就不会被阻塞在此，会直接返回。
}

sync.WaitGroup

介绍

sync.WaitGroup 是 Go 语言标准库中的一个同步原语，用于等待一组 Go 协程完成其任务。它通常用于确保在主协程退出之前，所有其他协程都已经完成了它们的工作。下面是 sync.WaitGroup 的详细介绍和使用方法：

sync.WaitGroup 结构体

sync.WaitGroup 是一个结构体，它包含一个整数计数器和一些方法来管理该计数器。主要的方法有：

1. Add(delta int)：增加计数器的值，可以为正数或负数。通常在启动一个新的 Go 协程时调用，以表示有一个新的任务需要等待完成。

2. Done()：减少计数器的值，通常在协程完成其任务时调用，以表示一个任务已经完成。

3. Wait()：等待计数器的值变为零。如果计数器不为零，它将阻塞调用协程，直到计数器归零为止。

原理

使用示例

下面是一个使用 sync.WaitGroup 的示例，说明了如何等待一组协程完成任务：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 在协程结束时减少计数器的值

    fmt.Printf("Worker %d is working\n", id)
}

func main() {
    var wg sync.WaitGroup

    numWorkers := 5

    for i := 1; i <= numWorkers; i++ {
        wg.Add(1) // 增加计数器的值，表示有一个新的任务
        go worker(i, &wg)
    }

    wg.Wait() // 等待所有协程完成任务

    fmt.Println("All workers have finished.")
}

在这个示例中，我们创建了一个 sync.WaitGroup 对象 wg，并启动了5个协程来执行 worker 函数。每个协程在工作完成后调用 wg.Done() 来减少计数器的值。最后，我们调用 wg.Wait() 来等待所有协程完成任务，一旦计数器的值变为零，程序将继续执行，输出 “All workers have finished."。

这个示例展示了如何使用 sync.WaitGroup 来等待一组协程完成任务，确保所有工作都已经完成再继续执行后续的代码。这在并发编程中非常有用，特别是在需要等待一组协程完成某项工作时。

互斥锁

互斥锁（Mutex）是 Go 语言标准库中的一种同步原语，用于控制多个协程对共享资源的访问，确保在同一时刻只有一个协程可以访问共享资源，从而避免竞态条件（Race Condition）。下面是互斥锁的详细介绍和使用方法：

互斥锁的结构体

Go 语言中的互斥锁通过 sync 包中的 Mutex 结构体来实现。主要的方法有：

1. Lock()：用于获取锁。如果锁已经被其他协程获取，那么调用 Lock 的协程将被阻塞，直到锁被释放为止。

2. Unlock()：用于释放锁。一旦一个协程完成了对共享资源的访问，应该调用 Unlock 来释放锁，以便其他协程可以获取锁并继续访问共享资源。

使用示例

下面是一个简单的示例，演示了如何在 Go 中使用互斥锁来保护共享资源：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

var (
    counter int
    mutex   sync.Mutex // 创建一个互斥锁
)

func increment() {
    mutex.Lock()   // 获取锁
    defer mutex.Unlock() // 在函数退出时释放锁

    counter++
}

func main() {
    numIterations := 1000
    var wg sync.WaitGroup

    for i := 0; i < numIterations; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            increment()
        }()
    }

    wg.Wait() // 等待所有协程完成

    fmt.Println("Counter:", counter)
}

在这个示例中，我们创建了一个名为 counter 的共享变量，并使用 sync.Mutex 创建了一个互斥锁 mutex。在 increment 函数中，我们首先通过调用 mutex.Lock() 来获取锁，然后在函数退出时使用 defer mutex.Unlock() 来释放锁。这确保了每次只有一个协程可以递增 counter 变量，避免了竞态条件。

在 main 函数中，我们启动了多个协程来并发地调用 increment 函数，递增 counter 变量的值。最后，我们等待所有协程完成（使用 sync.WaitGroup），然后输出最终的计数值。

互斥锁是在多协程并发访问共享资源时的一种重要工具，可以确保数据的安全性，防止竞态条件，但要注意，滥用互斥锁可能会导致性能问题，因为只有一个协程可以同时访问被保护的资源。因此，在设计并发程序时，需要权衡锁的使用，确保在必要的时候使用锁，但也不要过度使用。

读写锁

Go 语言中的读写锁（RWMutex）是一种同步原语，它允许多个协程同时读取共享资源，但只允许一个协程写入共享资源。这在某些场景下可以提高并发性能，因为多个协程可以同时读取数据而不需要互斥锁，但当有协程需要写入数据时，需要互斥锁来保护写操作。下面是读写锁的详细介绍和使用方法：

读写锁的结构体

Go 语言中的读写锁通过 sync 包中的 RWMutex 结构体来实现。主要的方法有：

1. RLock()：用于获取读锁。多个协程可以同时获取读锁，只要没有协程持有写锁。如果有协程持有写锁，那么获取读锁的协程将被阻塞，直到写锁被释放。

2. RUnlock()：用于释放读锁。一旦一个协程完成了对共享资源的读取，应该调用 RUnlock 来释放读锁。

3. Lock()：用于获取写锁。当有协程持有读锁或写锁时，获取写锁的协程将被阻塞，直到所有读锁被释放。写锁是排他的，只有一个协程可以获取写锁。

4. Unlock()：用于释放写锁。一旦一个协程完成了对共享资源的写入，应该调用 Unlock 来释放写锁。

使用示例

下面是一个示例，演示了如何在 Go 中使用读写锁来保护共享资源：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

package main

import (
    "fmt"
    "sync"
    "time"
)

var (
    data    map[string]int
    rwMutex sync.RWMutex // 创建一个读写锁
)

func init() {
    data = make(map[string]int)
}

func readData(key string) int {
    rwMutex.RLock() // 获取读锁
    defer rwMutex.RUnlock() // 在函数退出时释放读锁

    return data[key]
}

func writeData(key string, value int) {
    rwMutex.Lock() // 获取写锁
    defer rwMutex.Unlock() // 在函数退出时释放写锁

    data[key] = value
}

func main() {
    numReaders := 5
    numWriters := 2
    var wg sync.WaitGroup

    for i := 0; i < numReaders; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            key := "foo"
            value := readData(key)
            fmt.Printf("Reader: Key=%s, Value=%d\n", key, value)
        }()
    }

    for i := 0; i < numWriters; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            key := "foo"
            value := 42
            writeData(key, value)
            fmt.Printf("Writer: Key=%s, Value=%d\n", key, value)
        }()
    }

    wg.Wait() // 等待所有协程完成
}

在这个示例中，我们创建了一个共享的 data map，然后使用 sync.RWMutex 创建了一个读写锁 rwMutex。readData 函数用于读取共享数据，它首先获取读锁，然后在函数退出时释放读锁。writeData 函数用于写入共享数据，它获取写锁，然后在函数退出时释放写锁。

在 main 函数中，我们启动了多个读取协程和写入协程，它们可以并发地读取和写入共享数据。由于读操作使用了读锁，多个读取协程可以同时进行，而写操作使用了写锁，只有一个写入协程可以进行。这样可以提高并发性能，同时确保数据的一致性和安全性。

读写锁适用于读多写少的场景，可以有效地降低读操作的竞争，提高程序的性能。但需要小心使用，不要滥用读写锁，否则可能引入复杂性和潜在的问题。

定时任务

只执行一次

使用time.After()或time.NewTimer()来实现定时任务。

可以使用timer.Stop()提前中止定时任务，使用timer.Reset()重置定时任务。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

var order = stopOrReset()

func main() {
    //timing() // 两种定时任务的实现
    // 如果提前完成定时要处理的业务， 或者需要调整时间 怎么办？
    // 定时器的中止与重置： timer.Stop() timer.Reset()
    timingWithStopOrReset() // 中止或重置timer
}

func timing() {
    // 方式1：time.After()
    fmt.Println(time.Now().Format("2006-01-02 15:05:05"))
    rTime := <-time.After(time.Second * 3) // time.After()返回一个只读的管道，在阻塞指定的时间后，函数内部向管道中写入一个Time类型的数据，让程序可以继续往下执行。
    // time.After()的返回值是阻塞完成之后的时间值
    fmt.Println("rTime:", rTime.Format("2006-01-02 15:05:05")) // rTime==time.Now()
    fmt.Println(time.Now().Format("2006-01-02 15:05:05"))

    // time.After()内部使用的是：NewTimer(d).C
    // 方式2：time.NewTimer()
    fmt.Println(time.Now().Format("2006-01-02 15:05:05"))
    timer := time.NewTimer(time.Second * 3)
    t := <-timer.C
    fmt.Println(t.Format("2006-01-02 15:05:05"))
}

func timingWithStopOrReset() {
    timer := time.NewTimer(time.Second * 3)
    fmt.Println(time.Now())
    if order == "stop" { // 如果满足条件，则提前终止
       fmt.Println("提前中止...")
       timer.Stop() // 提前中止定时  如果停止了timer，还去拿，就会报错：fatal error: all goroutines are asleep - deadlock!
    } else if order == "reset" {
       fmt.Println("定时重置...")
       timer.Reset(time.Second * 5) // 定时重置为5s
       t := <-timer.C
       fmt.Println(t)
    } else {
       t := <-timer.C
       fmt.Println("时间结束，任务终止...")
       fmt.Println(t)
    }
}

func stopOrReset() string {
    var str string
    _, err := fmt.Scanln(&str)
    if err != nil {
       panic(err)
    }
    return str
}

循环定时任务

采用time.NewTicker()实现循环定时任务。 可以使用time.NewTimer()，每次执行完之后，手动timer.Reset()新的定时就可以了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

var (
    wg      sync.WaitGroup
    taskNum = 5
)

func main() {
    newTickerMethod()
    newTimerMethod() // 效果同newTickerMethod
}

func newTickerMethod() {
    ticker := time.NewTicker(time.Second) // 使用time.NewTicker()的方式，每隔1s执行一次定时任务
    count := 0
    wg.Add(1)
    go func() {
       defer wg.Done()
       defer ticker.Stop()
       for {
          count++
          t := <-ticker.C
          fmt.Println(t)
          if count >= taskNum { // 控制定时任务执行的次数
             return
          }
       }
    }()
    wg.Wait()
    fmt.Println("程序结束！")
}

func newTimerMethod() {
    timer := time.NewTimer(time.Second) // 使用time.NewTimer()的方式
    count := 0
    wg.Add(1)
    go func() {
       defer wg.Done()
       defer timer.Stop()
       for {
          count++
          t := <-timer.C
          fmt.Println(t)
          timer.Reset(time.Second) // 重置定时时间
          if count >= taskNum {
             return
          }
       }
    }()
    wg.Wait()
    fmt.Println("程序结束！")
}

time.After 和 time.Sleep的区别

time.After 和 time.Sleep 都涉及到 Go 语言中的时间控制，但它们在用途和行为上有一些关键的区别：

1. time.After：

   • time.After 是一个返回 chan time.Time 的函数，它会在指定的时间间隔之后向通道发送一个时间值。

   • 通常用于在指定的时间间隔后执行某个操作，例如超时控制、定时任务触发等。

   • time.After 不会阻塞当前协程，而是立即返回一个通道，然后你可以通过 select 语句等待通道的值到达，从而触发相关操作。

   • 例如，使用 select 和 time.After 来实现一个简单的超时控制：

     1 2 3 4 5

     select { case <-time.After(5 * time.Second): // 在5秒后执行此代码 fmt.Println("超时") }

2. time.Sleep：

   • time.Sleep 是一个函数，它会导致当前协程休眠指定的时间间隔，让协程暂停执行。

   • 主要用于在协程内部进行等待或暂停，例如执行一些周期性的任务或简单的延迟操作。

   • time.Sleep 会阻塞当前协程的执行，直到指定的时间间隔过去后再继续执行后续代码。

   • 例如，使用 time.Sleep 来实现一个协程内的延迟操作：

     1 2	time.Sleep(2 * time.Second) fmt.Println("2秒后执行此代码")

总结来说，time.After 主要用于在协程之间触发操作，而 time.Sleep 主要用于在协程内部进行休眠或延迟。它们的选择取决于你的具体需求，例如是否需要等待通道触发、是否需要协程内部休眠等。

time.Sleep() 本身是不能中止的，因为它是用于让当前协程休眠指定的时间间隔，而不提供直接的方法来取消休眠。而time.NewTimer()可以使用time.Stop()来中止定时任务。

通道

2023.10.06

介绍

通道（Channel）是Go语言中一种重要的并发编程工具，用于在不同goroutine之间进行通信和同步。通道可以帮助解决多个goroutine之间的数据竞态（Data Race）问题，从而实现安全的并发操作。

channel内部使用了互斥锁来保证并发的安全。

以下是Go语言中通道的详细介绍：

1. 通道的创建： 你可以使用内置的make函数来创建通道，指定通道的类型。通道可以是带缓冲的或非带缓冲的。带缓冲的通道允许在通道满之前存储一定数量的元素，而非带缓冲的通道则只能在发送和接收操作匹配时才能进行通信。

   1 2	// 创建一个带缓冲的通道，可以存储3个整数 ch := make(chan int, 3)

2. 通道的发送和接收： 使用通道的箭头操作符<-进行数据的发送和接收。发送操作将数据发送到通道，接收操作从通道中接收数据。通道的发送和接收操作是阻塞的，直到另一端准备好。

   1 2 3 4 5

   // 发送数据到通道 ch <- 42 // 从通道中接收数据 value := <-ch

3. 通道的关闭： 通道可以被关闭，以通知接收者不再有数据需要接收。关闭后的通道仍然可以被接收，但不再可以发送数据。关闭通道是一种好的实践，可以避免死锁。

   1

   close(ch)

4. 通道的遍历： 你可以使用range关键字来遍历通道。当通道被关闭时，range会自动退出。

   1 2 3

   for value := range ch { // 处理通道中的数据 }

5. 通道的选择： select语句允许你在多个通道操作之间进行选择，以便非阻塞地进行通信。它可以用于处理多个通道的并发操作。

   1 2 3 4 5 6 7 8 9 10

   select { case msg1 := <-ch1: // 处理从ch1接收到的数据 case msg2 := <-ch2: // 处理从ch2接收到的数据 case ch3 <- data: // 将数据发送到ch3 default: // 如果没有通道准备好，执行默认操作 }

6. 通道的同步： 通道还可以用于同步goroutine。通过通道，你可以等待其他goroutine完成某个任务，或者通知其他goroutine开始执行某个任务。

7. 通道的使用场景： 通道通常用于多个goroutine之间的数据传递和协调，例如生产者-消费者问题、工作池等。

8. 避免死锁： 在使用通道时要特别小心死锁情况，即一些goroutine在等待某个事件发生，但该事件无法发生。要避免死锁，确保在发送或接收数据时有足够的通信机制。

通道是Go语言并发编程中非常强大的工具，可以安全且有效地处理并发操作。但也需要小心使用，以避免潜在的问题，如死锁或资源竞争。在编写并发代码时，始终遵循最佳实践以确保程序的正确性和性能。

无缓冲通道和带缓冲通道

在Go语言中，通道可以分为无缓冲通道和带缓冲通道，它们有以下主要区别：

1. 容量：

   • 无缓冲通道（Unbuffered Channel）：无缓冲通道没有存储元素的缓冲区，发送操作和接收操作必须同时准备好，否则它们会阻塞，直到双方都准备好。

     下面的代码会造成死锁，因为发送方和接收方无法同时准备好。

     1 2 3

     intChan := make(chan int) intChan <- 13 <-intChan

   • 带缓冲通道（Buffered Channel）：带缓冲通道有一个存储元素的缓冲区，可以存储一定数量的元素。发送操作只要缓冲区未满就不会阻塞，接收操作只要缓冲区不为空就不会阻塞。

2. 阻塞特性：

   • 无缓冲通道：发送和接收操作都是阻塞的，只有当发送者和接收者都准备好时，数据才会被传递。
   • 带缓冲通道：发送操作只有在缓冲区满时才会阻塞，接收操作只有在缓冲区为空时才会阻塞。

3. 同步 vs 异步：

   • 无缓冲通道是用于同步goroutine的工具，它强制发送者和接收者在同一时刻准备好，以确保数据的安全传递。这种同步机制使得无缓冲通道适用于实现互斥锁和条件变量等同步原语。
   • 带缓冲通道允许异步操作，发送者和接收者可以在不同时刻准备好。这使得带缓冲通道适用于解耦发送者和接收者的速度，以提高程序的并发性能。

4. 长时间阻塞：

   • 无缓冲通道可能会导致较长时间的阻塞，因为发送者和接收者必须在同一时刻准备好。
   • 带缓冲通道可以减少某些情况下的长时间阻塞，因为发送者可以向缓冲区发送数据而不等待接收方准备好。

5. 选择语句：

   • 带缓冲通道与select语句结合使用时可以用于非阻塞地进行通信和同步，而无缓冲通道通常需要直接的发送和接收操作以进行同步。

选择使用无缓冲通道还是带缓冲通道取决于具体的应用场景。通常情况下，无缓冲通道用于强制同步操作，确保数据的安全传递，而带缓冲通道用于提高并发性能和解耦操作的速度。在并发编程中，根据需求选择适当的通道类型非常重要。

通道阻塞

通道在Go语言中会发生阻塞的条件取决于通道的类型和操作，主要有以下几种情况：

1. 无缓冲通道的阻塞：

   • 发送操作阻塞：如果一个goroutine试图向一个无缓冲通道发送数据，但没有其他goroutine准备好从通道接收数据，发送操作会阻塞，直到有接收者准备好。
   • 接收操作阻塞：如果一个goroutine试图从一个无缓冲通道接收数据，但没有其他goroutine准备好向通道发送数据，接收操作会阻塞，直到有发送者准备好。

   无缓冲通道的阻塞是用来强制发送者和接收者在同一时刻准备好，以确保数据的安全传递。

2. 带缓冲通道的阻塞：

   • 发送操作阻塞：如果一个goroutine试图向一个已满的带缓冲通道发送数据，发送操作会阻塞，直到有其他goroutine从通道接收数据来释放缓冲空间。
   • 接收操作阻塞：如果一个goroutine试图从一个空的带缓冲通道接收数据，接收操作会阻塞，直到有其他goroutine向通道发送数据。

   带缓冲通道的阻塞是由通道的缓冲区状态决定的。

3. select语句中的阻塞：

   • 当使用select语句时，如果所有通道操作都不能立即执行，select语句会阻塞，等待其中一个通道操作可以执行。
   • 如果多个通道操作可以立即执行，select会随机选择一个执行。如果有default子句，而其他通道操作都无法立即执行，那么将执行default子句，或者如果没有default子句，则select会阻塞。

4. 关闭通道的影响：

   • 关闭通道后，可以无阻塞地从通道接收数据。接收操作将从通道中读取所有已经发送的数据，然后返回通道类型的零值。
   • 如果你试图向一个已经关闭的通道发送数据，会导致panic。

5. 被置为nil的管道：

   当管道为nil时，对其读写操作都会阻塞，但不会导致panic。

总的来说，通道阻塞的主要条件涉及发送和接收操作，以及通道的状态（有缓冲或无缓冲）。在并发编程中，要特别小心处理阻塞情况，以避免死锁和其他并发问题。使用select语句可以帮助你在多个通道操作之间进行选择，以实现非阻塞的通信和同步。

内存泄漏

当通道读写次数不对等时，会出现内存泄漏的问题。如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

func main() {
    intChan := make(chan int, 5)
    go func() {
       for i := 0; i < 30; i++ { // 写入30次，但只读了20次，管道容量为5，导致该协程一直被阻塞，造成内存泄漏。
          intChan <- i
          fmt.Println("写入：", i)
       }
       close(intChan) // 写完之后，关闭管道
    }()

    go func() {
       for i := 0; i < 20; i++ {
          fmt.Println("等待读...")
          data := <-intChan
          fmt.Println("<---读出：", data)
       }
    }()
    time.Sleep(time.Second * 4)
}

for-range读取通道

使用for-range的方式可以防止读写次数不一致的问题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

func main() {
    intChan := make(chan int, 5)
    go func() {
       for i := 0; i < 30; i++ {
          intChan <- i
          fmt.Println("写入：", i)
       }
       close(intChan) // 写完之后，关闭管道
    }()

    go func() {
       for v := range intChan {
          fmt.Println("<---读出：", v)
       }
    }()
    time.Sleep(time.Second * 4)
}

判断通道是否关闭

如果对于未关闭的空管道进行读取，则会被一直阻塞。

如果对已经关闭的空管道进行读取，会返回零值和是否成功的标识（和判断map的key是否存在相同，这种方式被称为ok-idom模式）

单向通道

单向通道（One-way Channel）是一种通道，限制了通道的发送或接收操作的方向，使其只能用于发送或接收数据，而不能同时用于发送和接收。单向通道通常用于在函数参数中传递通道，以强制函数的行为。

在Go语言中，你可以将一个双向通道转换为单向通道，但不能将一个单向通道转换回双向通道。单向通道有两种类型：只能发送的通道和只能接收的通道。

以下是单向通道的示例和说明：

1. 只能发送的通道（Send-Only Channel）：

   • 定义方式：chan<- T，其中 T 是通道中元素的类型。
   • 只能用于发送数据到通道，不能用于接收数据。
   • 示例：

   1 2 3 4 5 6

   func sendData(ch chan<- int) { ch <- 42 } ch := make(chan int) go sendData(ch)

2. 只能接收的通道（Receive-Only Channel）：

   • 定义方式：<-chan T，其中 T 是通道中元素的类型。
   • 只能用于从通道接收数据，不能用于发送数据。
   • 示例：

   1 2 3 4 5 6

   func processData(ch <-chan int) { data := <-ch } ch := make(chan int) go processData(ch)

单向通道的主要优势在于它们可以用于强制函数的行为。例如，如果你希望一个函数只能向通道发送数据而不能从通道接收数据，可以将该通道声明为只能发送的通道类型，从而确保函数不会意外地从通道接收数据。

需要注意的是，一旦将通道转换为单向通道类型，就只能在该类型的方向上执行操作，不再能够进行双向的发送和接收操作。这种限制有助于编写更安全和可维护的代码。

双向通道的参数可以传递给单向通道，但是不能反过来。

select

介绍

select 是Go语言中用于处理多个通道操作的控制结构。它允许在多个通道之间进行非阻塞的选择，等待其中一个通道准备好并执行相应的操作。select 语句通常用于协调并发操作，处理I/O多路复用以及实现超时等场景。

以下是 select 的详细介绍和使用方法：

1. 基本语法：

   1 2 3 4 5 6 7 8 9 10

   select { case <-channel1: // 处理 channel1 的操作 case data := <-channel2: // 处理 channel2 的操作，同时将数据存储在变量 data 中 case channel3 <- value: // 向 channel3 写入数据 value default: // 如果没有通道准备好，则执行 default 分支（可选） }

   • select 语句包含多个 case 分支，每个分支对应一个通道操作或默认操作。
   • 如果其中一个通道准备好了（可读或可写），则相应的分支将被执行。
   • 如果没有通道准备好，且存在 default 分支，那么 default 分支将被执行。

2. 用途：

   • select 常用于处理多个通道的非阻塞操作，例如等待多个goroutine完成工作或选择最快响应的通道。
   • 可用于实现超时机制，等待某个通道操作一定时间，然后执行其他操作。
   • 在实现I/O多路复用时，可以使用 select 监听多个网络或文件描述符上的事件。
   • select 还用于避免goroutine泄漏或死锁，可以通过通道的关闭来通知其他goroutine停止运行。

3. 示例：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

   func main() { ch1 := make(chan int) ch2 := make(chan int) go func() { time.Sleep(1 * time.Second) ch1 <- 42 }() go func() { time.Sleep(2 * time.Second) ch2 <- 99 }() select { case value := <-ch1: fmt.Println("Received from ch1:", value) case value := <-ch2: fmt.Println("Received from ch2:", value) case <-time.After(3 * time.Second): fmt.Println("Timeout") } }

   在这个示例中，select 等待 ch1 或 ch2 准备好，同时还设置了一个3秒的超时。一旦其中一个通道准备好，相应的 case 分支将被执行。如果3秒内没有任何通道准备好，那么超时分支将被执行。

总之，select 语句是Go语言中强大的并发控制工具，它允许在多个通道之间选择，并且可以用于解决各种并发编程的问题。通过合理使用 select，可以实现高效、安全的并发操作。

随机性

在Go语言中，select 语句用于处理通道（Channel）的多路选择，通常用于等待多个通道中的其中一个完成。在 select 语句中，如果多个通道都准备好了（可以进行读取或写入操作），那么Go语言会随机选择一个可用的通道来执行操作。

这种随机性是由Go运行时调度器实现的，它会在多个可用通道之间进行随机选择，以确保公平性和避免死锁。这也意味着程序员无法精确地控制 select 语句的选择顺序，它是不确定的。

以下是一个简单的示例，演示了 select 的随机性：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package main

import (
	"fmt"
	"time"
)

func main() {
	ch1 := make(chan string)
	ch2 := make(chan string)

	go func() {
		time.Sleep(1 * time.Second)
		ch1 <- "Channel 1"
	}()

	go func() {
		time.Sleep(2 * time.Second)
		ch2 <- "Channel 2"
	}()

	select {
	case msg1 := <-ch1:
		fmt.Println(msg1)
	case msg2 := <-ch2:
		fmt.Println(msg2)
	}
}

在这个示例中，有两个goroutine分别向两个通道 ch1 和 ch2 发送消息。然后，select 语句随机选择一个可用通道，并打印相应的消息。由于通道的操作时间不确定，所以你可能会看到不同的输出顺序，这取决于哪个通道先准备好。

总之，select 语句的随机性是Go语言中的一种特性，它确保了在多个通道之间进行公平的选择，但程序员不能控制选择的顺序。这种不确定性可以帮助避免死锁和提高并发性能。

select阻塞

select{}是一个没有任何case的select，会一直阻塞导致死锁。

1
2
3

func main() {
    select {}
}

判断通道是否阻塞

1
2
3
4
5
6

var ch chan int = make(chan int,5)
select {
    case ch<- data:
    	fmt.Println("add syccess")
    default:  // channel满了
}

select timeout模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func main(){
    result := make(chan string)
	go func() {
    	//模拟网络访问
    	time.Sleep(8* time.Second)
		result <-"服务端结果"
	}()
    select {
    case V := <-result:
		fmt.Println(v)
	case <-time.After(5* time.Second):
        fmt.Println("网络访问超时了")
    }
}

对象池

使用带缓冲的管道实现对象池。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

type ReusableObj struct {}

type ObjPool struct {
    bufChan chan *ReusableObj
}

func NewObjPool(numOfObj int) *ObjPool {
    objPool := ObjPool{}
    objPool.bufChan = make(chan *ReusableObj, numOfObj)
    for i := 0; i < numOfObj; i++ {
       objPool.bufChan <- &ReusableObj{}
    }
    return &objPool
}

func (p *ObjPool) GetObj(timeout time.Duration) (*ReusableObj, error) {
    select {
    case ret := <-p.bufChan:
       return ret, nil
    case <-time.After(timeout): // 超时控制
       return nil, errors.New("time out")
    }
}

func (p *ObjPool) ReleaseObj(obj *ReusableObj) error {
    select {
    case p.bufChan <- obj:
       return nil
    default:
       return errors.New("overflow")
    }
}

func main() {
    pools := NewObjPool(10)

    for i := 0; i < 10; i++ { // 在不放回的情况下，如果取的数量超过了连接池中连接的数量，会报超时的错误。
       if v, err := pools.GetObj(time.Second); err != nil {
          panic(err)
       } else {
          fmt.Println("v:", unsafe.Pointer(v))

          // 对连接进行的操作....

          if err := pools.ReleaseObj(v); err != nil { // 操作完成后，将连接放回连接池
             panic(err)
          }
       }
    }
    fmt.Println("Done")
}

在使用时不是一定会提高程序的性能，因为需要考虑带缓冲的管道带来的锁的机制，为了保证线程安全的同步机制对性能的影响。

sync包

介绍

sync 包是 Go 语言标准库中提供的用于并发编程的包，它包含了一些用于同步和互斥操作的工具，帮助开发者处理并发的问题。以下是 sync 包的主要组件和功能的详细介绍：

1. 互斥锁（sync.Mutex）：

   • sync.Mutex 是一个互斥锁类型，用于保护共享资源，以防止多个协程同时访问或修改。

   • 你可以使用 Lock 方法锁定互斥锁，以阻止其他协程访问受保护的资源，使用 Unlock 方法解锁互斥锁，以允许其他协程访问资源。

   • 互斥锁适用于临界区的互斥访问，以确保数据的一致性和可靠性。

2. 读写锁（sync.RWMutex）：

   • sync.RWMutex 是一个读写锁类型，它支持多个协程同时读取共享资源，但只允许一个协程写入共享资源。

   • 你可以使用 RLock 方法锁定读写锁以进行读取操作，使用 RUnlock 方法解锁读写锁，以允许其他协程进行读取操作。

   • 使用 Lock 方法锁定读写锁以进行写入操作，使用 Unlock 方法解锁读写锁，以允许其他协程进行读取或写入操作。

3. 条件变量（sync.Cond）：

   • sync.Cond 是一个条件变量类型，它允许协程等待某个条件的发生，并在条件满足时被唤醒。

   • Cond 通常与互斥锁一起使用，以确保条件检查和等待的操作是线程安全的。

   • 你可以使用 Wait 方法等待条件的发生，使用 Signal 方法唤醒一个等待的协程，使用 Broadcast 方法唤醒所有等待的协程。

4. 等待组（sync.WaitGroup）：

   • sync.WaitGroup 是一个等待组类型，它用于等待一组协程完成它们的任务。

   • 你可以使用 Add 方法增加等待组的计数器，使用 Done 方法减少计数器，使用 Wait 方法等待计数器变为零。

   • 等待组通常用于等待一组协程完成并发操作，然后继续执行其他任务。

5. 原子操作（sync/atomic 包）：

   • sync/atomic 包提供了一组原子操作函数，用于在多个协程之间安全地进行原子操作，例如原子增加、减少、交换等。

   • 原子操作可以用于实现锁、计数器等各种并发数据结构。

6. 一些其他工具：

   • sync 包还提供了一些其他用于同步的工具和函数，例如 Once 用于执行某个函数一次，Map 用于安全地并发访问映射等。

总之，sync 包是 Go 语言标准库中提供的用于并发编程的基本工具集，它帮助开发者处理并发、同步和互斥的问题，确保多个协程之间的正确协作和数据安全。使用这些工具可以更容易地编写并发安全的 Go 代码。

sync.Pool

• sync.Pool 是用于池化临时对象的类型。它可以用于重用分配的对象，以减少内存分配和垃圾回收的开销。

• 你可以使用 Get 方法从池中获取对象，使用 Put 方法将对象放回池中。

• sync.Pool 通常用于提高性能，特别是在需要频繁分配和释放对象的场景中，例如连接池、临时缓冲区等。

• 示例：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  var objectPool = sync.Pool{ New: func() interface{} { return "New Object" }, } func main() { obj := objectPool.Get().(string) fmt.Println(obj) // 将对象放回池中 objectPool.Put(obj) // 再次获取对象，应该是之前放回的对象 obj = objectPool.Get().(string) fmt.Println(obj) }

sync.Pool对象获取

• 尝试从私有对象获取
• 私有对象不存在，尝试从当前 Processor 的共享池获取
• 如果当前 Processor 共享池也是空的，那么就尝试去其他Processor 的共享池获取
• 如果所有子池都是空的，最后就用用户指定的 New 函数产生一个新的对象返回

sync.Pool对象的生命周期

• GC会清除 sync.pool 缓存的对象
• 对象的缓存有效期为下一次 GC之前

总结

• 适合于通过复用，降低复杂对象的创建和 GC代价
• 协程安全，会有锁的开销
• 生命周期受 GC 影响，不适合于做连接池等，需自己管理生命周期的资源的池化

sync.Cond

sync.Cond 有三个方法

• Wait，阻塞当前协程
• Signal，唤醒一个等待时间最长的协程
• Broadcast，唤醒所有等待的协程

sync.Cond 是 Go 语言标准库中的一个条件变量（condition variable）类型，用于实现更复杂的同步和通信模式。条件变量允许协程在某个条件满足时等待或被唤醒，通常与互斥锁（sync.Mutex）一起使用，以实现协程之间的协作。以下是对 sync.Cond 的详细介绍：

1. 创建 sync.Cond 对象：

   使用 sync.NewCond 函数可以创建一个新的 sync.Cond 对象。通常，它与一个互斥锁一起使用，以确保在操作条件变量之前和之后的临界区是安全的。

   1 2	mu := sync.Mutex{} c := sync.NewCond(&mu)

2. 等待条件满足：

   协程可以使用 c.Wait() 方法来等待某个条件满足。当协程调用 c.Wait() 时，它会进入休眠状态，直到其他协程通过 c.Signal() 或 c.Broadcast() 唤醒它。

   1 2 3 4 5

   c.L.Lock() for !condition { c.Wait() } c.L.Unlock()

3. 唤醒等待的协程：

   通过 c.Signal() 方法可以唤醒一个等待的协程，而通过 c.Broadcast() 方法可以唤醒所有等待的协程。这些方法通常在某些条件满足时由其他协程调用。

   1 2 3 4

   c.L.Lock() condition = true c.Broadcast() // 或者使用 c.Signal() 唤醒单个等待的协程 c.L.Unlock()

4. 注意事项：

   • 在使用 sync.Cond 时，通常需要将条件检查和等待的操作包装在互斥锁的临界区内，以确保条件检查和等待操作的原子性。

   • 在等待之前和之后，必须使用互斥锁锁定和解锁条件变量。

   • sync.Cond 通常用于多个协程之间的同步和通信，以实现更复杂的协作模式，例如生产者-消费者模式。

   • 请小心避免死锁和竞争条件，确保正确使用互斥锁和条件变量来保护共享资源。

sync.Cond 是 Go 语言标准库提供的一个强大工具，用于协程之间的协作和同步。它通常用于处理更复杂的并发问题，例如等待某些条件满足或等待多个协程协作完成某项任务。使用 sync.Cond 需要仔细设计和实现，以确保正确性和性能。

sync.Map

sync.Map 在 Go 1.9 中引入，是 Go 语言标准库中提供的一种用于并发安全的键值存储的数据结构。它在多个协程之间可以安全地进行读写操作，而无需额外的锁操作，因此在某些并发性能要求较高的场景中非常有用。下面是对 sync.Map 的详细介绍：

1. 并发安全性：

   sync.Map 是并发安全的，可以在多个协程之间进行并发读写操作而不会发生竞态条件。这是因为它内部使用了一些特殊的数据结构和锁机制来实现并发安全性。

2. 无需显式的锁：

   与传统的 map 不同，sync.Map 不需要在每个操作之前显式地加锁或解锁。这意味着你可以在不同的协程中读写 sync.Map 而无需担心锁的管理。

3. 键值对的存储和检索：

   你可以使用 Load 方法来检索键对应的值，使用 Store 方法来存储键值对。Load 和 Store 方法是 sync.Map 中的核心方法。

4. 删除键值对：

   你可以使用 Delete 方法来删除指定键的键值对。

5. 迭代：

   sync.Map 提供了 Range 方法，可以用于迭代键值对。它接受一个回调函数作为参数，在每个键值对上调用回调函数。

6. 零值：

   sync.Map 的零值是一个可以直接使用的空 map。不需要额外的初始化。

7. 适用场景：

   sync.Map 适用于读多写少的场景，因为在写操作时仍然会有一些开销，但读操作可以并发执行而不需要锁。这使得它特别适合于高并发的读操作，例如缓存。

下面是一个简单的示例，演示了如何使用 sync.Map：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map

    // 存储键值对
    m.Store("key1", "value1")
    m.Store("key2", "value2")

    // 读取键值对
    if value, ok := m.Load("key1"); ok {
        fmt.Println("key1:", value)
    }

    // 删除键值对
    m.Delete("key2")

    // 遍历键值对
    m.Range(func(key, value interface{}) bool {
        fmt.Printf("Key: %v, Value: %v\n", key, value)
        return true
    })
}

请注意，虽然 sync.Map 在某些情况下非常有用，但在其他情况下，普通的 map 加锁或其他并发数据结构可能更适合你的需求。在选择数据结构时，需要根据具体的并发需求和性能特点来决定。

内置测试框架

单元测试

Go语言提供了一个内置的测试框架，使得编写单元测试变得非常容易。单元测试用于验证你的代码的各个部分是否按照预期工作。以下是进行Go语言单元测试的一般步骤：

1. 创建测试文件：创建一个以_test.go为后缀的测试文件，例如mycode_test.go。这个文件应该与要测试的代码文件位于同一个目录中。

2. 导入testing包：在测试文件中导入testing包，这是Go语言的测试框架。

3. 编写测试函数：在测试文件中编写以Test开头的测试函数，这些函数的签名为func TestXxx(t *testing.T)，其中Xxx是你要测试的函数或方法的名称，t *testing.T是测试的上下文对象。

4. 使用t.Error和t.Fail来报告测试失败：在测试函数中，使用t.Error和t.Fail来报告测试是否失败。如果测试失败，你可以使用这些函数输出有关失败的信息。

5. 运行测试：使用go test命令来运行测试。可以在项目的根目录或包含测试文件的目录中运行此命令。Go会自动识别和运行测试文件中的测试函数，并生成测试报告。

以下是一个示例的测试文件和测试函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

package mycode

import (
	"testing"
)

func MyFunction(x int, y int) int {
	return x + y
}

func TestMyFunction(t *testing.T) {
	result := MyFunction(2, 3)
	if result != 5 {
		t.Errorf("Expected 5, but got %d", result)
	}
}

要运行这个测试，你可以在终端中使用以下命令：

1

go test

Go会自动运行测试文件中的测试函数，并输出测试结果。如果测试通过，将显示一个通过的消息；如果测试失败，将显示失败的消息和详细的错误信息。

你可以编写多个测试函数来覆盖代码的不同路径和边界条件，确保代码在各种情况下都能正常工作。单元测试对于保持代码的稳定性和可维护性非常重要。如果你的代码库规模较大，还可以考虑使用表格驱动测试来更有效地组织测试用例。

错误类型

Fail，Error：该测试失败，该测试继续，其他测试继续执行。

FailNow，Fatal: 该测试失败，该测试中止，其他测试继续执行。

在Go语言的单元测试中，通常使用testing.T对象的方法来报告和处理错误。testing.T对象提供了以下用于处理错误的方法：

1. t.Error(args ...interface{})：报告测试失败，但继续执行后续测试。

   例如：

   1	t.Error("This is an error message")

2. t.Errorf(format string, args ...interface{})：报告测试失败，并提供格式化的错误消息，但继续执行后续测试。

   例如：

   1	t.Errorf("Expected %d, but got %d", expected, actual)

3. t.Fail()：报告测试失败，但继续执行后续测试。

   例如：

   1 2 3

   if condition { t.Fail() }

4. t.FailNow()：报告测试失败并立即终止当前测试函数的执行。不会执行后续的测试代码。

   例如：

   1 2 3

   if condition { t.FailNow() }

5. t.Fatal(args ...interface{})：报告测试失败并立即终止当前测试函数的执行，不会执行后续的测试代码。

   例如：

   1	t.Fatal("This is a fatal error")

6. t.Fatalf(format string, args ...interface{})：报告测试失败并提供格式化的错误消息，然后立即终止当前测试函数的执行，不会执行后续的测试代码。

   例如：

   1	t.Fatalf("Expected %d, but got %d", expected, actual)

这些方法允许你在测试函数中处理错误，报告不符合预期的情况，以及提供详细的错误信息。通常情况下，使用Error、Errorf、Fail 和 FailNow 来报告测试失败，并继续执行其他测试用例，而使用 Fatal 和 Fatalf 来报告测试失败并立即终止测试函数的执行。

请注意，测试函数中的错误报告将被捕获并汇总到测试报告中，以便你可以轻松地查看所有失败的测试用例和错误消息。这有助于快速识别和修复问题。

查看单元测试覆盖率

1

go test --coverprofile main.cover -v ./ 

查看未覆盖的代码

1

go tool cover -html main.cover -o main.html

这个命令会生成一个html文件，打开这个html文件，可以看到为被测试覆盖的代码片段。

基准测试

在Go语言中，你可以使用内置的testing包来进行基准测试（Benchmarking）。基准测试是一种评估代码性能的方法，它可以帮助你测量一段代码在不同输入条件下的性能表现。

下面是如何进行基准测试的一般步骤：

1. 创建一个以_test.go为文件后缀的测试文件，例如mycode_test.go。

2. 在测试文件中导入testing包，并定义一个以Benchmark开头的函数，例如BenchmarkMyFunction，该函数的参数类型为*testing.B。

3. 在Benchmark函数中，编写需要测试性能的代码，并使用b.N来指示要运行多少次测试循环，以便得到准确的性能指标。

4. 使用b.ResetTimer()在每次循环之前重置计时器，以避免初始化代码的计时干扰性能测量。

5. 运行基准测试时，使用go test -bench=.命令，其中.表示当前目录下的所有测试文件。

以下是一个基准测试的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package mycode

import (
	"testing"
)

func MyFunction(input int) int {
	// 假设这里有一个需要测试性能的函数
	return input * 2
}

func BenchmarkMyFunction(b *testing.B) {
	// 在Benchmark函数中编写需要测试性能的代码
	for i := 0; i < b.N; i++ {
		// 在这里调用需要测试性能的函数
		result := MyFunction(42)
		_ = result // 防止编译器优化未使用的结果
	}
}

要运行这个基准测试，你可以在终端中使用以下命令：

1

go test -bench=.

其中，-bench=.表示运行当前目录下的所有基准测试。运行后，你将看到一些性能测量信息，包括每次迭代的平均时间和迭代次数。这些信息可以帮助你评估代码在不同输入条件下的性能表现。

请注意，基准测试的结果可能受多个因素影响，包括硬件、操作系统和Go运行时的版本。因此，建议在相同的环境中多次运行基准测试，以获得更稳定的结果。基准测试通常用于优化代码性能，因此在性能关键的部分进行测试非常有用。

测试的命令行参数

在Go语言中，testing包支持一系列命令行参数，可以用于控制和配置单元测试的行为。以下是一些常见的测试命令行参数以及它们的描述：

1. -v 或 --verbose：以详细模式（verbose mode）运行测试，显示每个测试函数的执行结果以及测试函数的名称。这个参数通常用于查看更多关于测试执行的详细信息。

   例如：

   1	go test -v

2. -run：指定一个正则表达式来选择要运行的测试函数。只有匹配指定正则表达式的测试函数才会被运行。

   例如：

   1	go test -run=TestMyFunction

   这个命令会运行名称中包含 “TestMyFunction” 的测试函数。

3. -bench：运行基准测试，指定一个正则表达式来选择要运行的基准测试函数。只有匹配指定正则表达式的基准测试函数才会被运行。

   例如：

   1	go test -bench=.

   这个命令会运行当前目录下所有的基准测试函数。

4. -benchmem：在运行基准测试时，同时报告内存分配的信息。这个参数允许你查看基准测试函数的内存分配情况。

   例如：

   1	go test -bench=YourBenchmarkFunction -benchmem

   这个命令会运行指定的基准测试函数，并报告内存分配信息。

5. -count：指定要运行的测试次数。默认情况下，测试运行一次，但你可以使用 -count 参数来指定多次运行测试以更好地评估性能。

   例如：

   1	go test -count=10

   这个命令会运行测试函数 10 次。

6. -cover：运行测试并报告代码覆盖率信息，显示哪些代码行被测试覆盖，哪些没有被覆盖。

   例如：

   1	go test -cover

7. -coverprofile：将代码覆盖率信息输出到指定文件，以供进一步分析和报告。

   例如：

   1	go test -coverprofile=coverage.out

8. -covermode：指定代码覆盖模式，可以是 set, count, 或 atomic。默认是 set 模式。

   例如：

   1	go test -covermode=count

这些命令行参数允许你在运行测试时对测试的执行方式进行自定义和控制，以便获取更多关于测试和代码覆盖率的信息。在编写和运行单元测试时，这些参数是非常有用的工具。

easyjson

介绍

easyjson 是一个用于生成高性能 JSON 编解码的 Go 语言库。它通过生成专用的编码和解码函数，来避免了标准库 encoding/json 中的反射，从而提高了 JSON 操作的速度。下面是关于 easyjson 库的详细介绍：

1. 性能优化： easyjson 的主要目标是提供比标准库更高性能的 JSON 编解码。它通过代码生成来创建专用的编码和解码函数，而不是使用反射。这使得 easyjson 在序列化和反序列化 JSON 数据时更快速。

2. 代码生成： easyjson 利用 Go 的代码生成工具，生成专用的编码和解码函数。为了生成这些函数，你需要为你的数据结构编写一些特殊的注释。然后，easyjson 工具会基于这些注释来生成高效的 JSON 编解码代码。

3. 与标准库的兼容性： easyjson 的 API 设计与标准库的 encoding/json 包非常相似，因此可以轻松地替换标准库的 JSON 操作。你可以在不修改原有代码的情况下，将 easyjson 用于现有的项目。

4. 支持命令行工具： easyjson 提供了一个命令行工具，用于自动生成 JSON 编解码代码。你只需运行 easyjson 工具，并指定你的数据结构，它将自动生成相应的代码文件。

5. 可选性： easyjson 是一个可选库，你可以选择性地在需要性能优化的地方使用它。对于某些场景，标准库的 encoding/json 也许足够了，但在需要更高性能的情况下，可以考虑切换到 easyjson。

总之，easyjson 是一个用于提高 JSON 编解码性能的库，通过代码生成和专用的函数来实现。如果你的应用需要频繁地进行 JSON 操作，并且性能是关键因素，那么 easyjson 可能是一个不错的选择。你可以通过查看 easyjson 的文档和示例来深入了解如何使用它来提高 JSON 操作的性能。

使用

要使用 easyjson 库来生成高性能的 JSON 编解码代码，你需要按照以下步骤进行设置和使用：

1. 安装 easyjson 工具： 首先，你需要安装 easyjson 工具。你可以使用以下命令来安装它：

   1	go get -u github.com/mailru/easyjson/...

2. 为数据结构添加注释： 对于你想要进行 JSON 编解码的数据结构，你需要为它们添加特定的注释。easyjson 工具会根据这些注释生成编解码代码。例如：

   1 2 3 4 5 6

   //easyjson:json type Person struct { Name string `json:"name"` Age int `json:"age"` Email string `json:"email"` }

   在上面的示例中，我们为 Person 结构体添加了 //easyjson:json 注释，并为字段添加了 JSON 标签。

3. 生成代码： 在你的项目目录中，使用 easyjson 工具生成 JSON 编解码代码。运行以下命令：

   1	easyjson -all your_structs.go

   这将生成一个名为 your_structs_easyjson.go 的文件，其中包含了生成的编解码函数。

4. 使用生成的代码： 一旦生成了代码，你可以像使用标准库的 encoding/json 一样使用 easyjson 生成的编解码函数。例如：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   // 导入生成的 easyjson 文件 import ( "your_package/your_structs" ) // 编码 person := your_structs.Person{Name: "Alice", Age: 30, Email: "alice@example.com"} encoded, err := person.MarshalJSON() if err != nil { panic(err) } fmt.Println(string(encoded)) // 解码 var decoded your_structs.Person err = decoded.UnmarshalJSON(encoded) if err != nil { panic(err) } fmt.Printf("Decoded: %+v\n", decoded)

   你需要确保正确导入生成的 easyjson 文件，并且使用生成的编解码函数来处理 JSON 数据。

这样，你就可以使用 easyjson 生成的高性能 JSON 编解码代码来提高 JSON 数据的序列化和反序列化性能。记住，你只需要为需要性能优化的结构添加 //easyjson:json 注释，并运行 easyjson 工具来生成代码。

RESTful API

RESTful API（Representational State Transfer API）是一种基于HTTP协议的Web服务架构风格，它通过URL来表示资源，通过HTTP方法来执行对这些资源的操作。RESTful API 是一种设计和开发Web服务的规范，旨在提供一种简单、可扩展、易于理解和使用的方式来进行网络通信。

以下是 RESTful API 的详细介绍：

1. 资源（Resource）：

   • 在RESTful API中，资源是系统中的实体，可以是物理对象（如用户、订单、产品）或虚拟概念（如会话、权限）。
   • 资源由唯一的标识符（通常是URL）来表示。例如，一个用户资源可以用URL /users/1 来表示，其中 1 是用户的唯一标识符。

2. HTTP方法：

   • RESTful API 使用HTTP方法来执行对资源的操作，主要有以下几种常用的HTTP方法：
     • GET：用于获取资源的信息，通常用于读取操作。
     • POST：用于创建新的资源，通常用于写入操作。
     • PUT：用于更新资源的信息，通常用于替换操作。
     • PATCH：用于部分更新资源的信息。
     • DELETE：用于删除资源。

3. 状态无关性（Statelessness）：

   • RESTful API 是状态无关的，每个请求都包含足够的信息以便服务器能够理解并处理它，而不依赖于之前的请求。这使得API的设计更加简单和可扩展。

4. 使用HTTP状态码：

   • RESTful API 使用HTTP状态码来表示请求的结果，包括成功（例如200 OK）、资源未找到（例如404 Not Found）、权限问题（例如401 Unauthorized）等。
   • HTTP状态码使得客户端能够更好地理解请求的结果，并采取适当的行动。

5. URL设计：

   • RESTful API的URL应该具有清晰的结构，容易理解和记忆。通常，URL的路径部分表示资源的层次结构，而查询参数用于过滤和排序资源。

6. 数据格式：

   • RESTful API通常使用标准的数据格式来表示资源，如JSON或XML。JSON已经成为最常见的选择，因为它轻量、易于解析和生成，并且具有广泛的支持。

7. 版本控制：

   • 为了确保API的兼容性和稳定性，通常需要在API的URL中包含版本信息，例如/v1/users表示API的第一个版本的用户资源。

8. 认证和授权：

   • RESTful API通常需要认证和授权机制，以确保只有授权的用户能够访问某些资源或执行某些操作。常见的认证方式包括基本认证、令牌认证和OAuth。

9. 安全性：

   • RESTful API需要考虑安全性问题，包括防止SQL注入、跨站点脚本（XSS）攻击、跨站点请求伪造（CSRF）等。

10. 文档和描述：

    • 提供清晰的API文档和描述是非常重要的，以便开发者能够理解和正确使用API。通常，Swagger、OpenAPI等工具可用于生成API文档。