GO语言基础二-优快云博客

本文链接：https://blog.youkuaiyun.com/wqeffort/article/details/137639787

本文详细介绍了Go语言中的同步机制，包括互斥锁Mutex和读写锁RWMutex的使用，以及sync.WaitGroup、sync.Once和sync.Map的应用。此外，还探讨了指针、内存管理、垃圾回收、类型和接口的面向对象特性，以及测试、反射、排序和文件操作。内容涵盖从基础的内存分配到高级的并发控制，深入解析Go语言的关键特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

GO语言基础二

23.同步与锁

同步锁

Go语言包中的sync包提供了两种锁类型：sync.Mutex和sync.RWMutex，前者是互斥锁，后者是读写锁。

互斥锁是传统的并发程序对共享资源进行访问控制的主要手段，在Go中，似乎更推崇由channel来实现资源共享和通信。它由标准库代码包sync中的Mutex结构体类型代表。只有两个公开方法：调用Lock（）获得锁，调用unlock（）释放锁。

使用Lock()加锁后，不能再继续对其加锁（同一个goroutine中，即：同步调用），否则会panic。只有在unlock()之后才能再次Lock()。异步调用Lock()，是正当的锁竞争，当然不会有panic了。适用于读写不确定场景，即读写次数没有明显的区别，并且只允许只有一个读或者写的场景，所以该锁也叫做全局锁。

func (m *Mutex) Unlock()用于解锁m，如果在使用Unlock()前未加锁，就会引起一个运行错误。已经锁定的Mutex并不与特定的goroutine相关联，这样可以利用一个goroutine对其加锁，再利用其他goroutine对其解锁。

建议：同一个互斥锁的成对锁定和解锁操作放在同一层次的代码块中。使用锁的经典模式：

var lck sync.Mutex
func foo() {
   
    lck.Lock() 
    defer lck.Unlock()
    // ...
}

lck.Lock()会阻塞直到获取锁，然后利用defer语句在函数返回时自动释放锁。

下面代码通过3个goroutine来体现sync.Mutex 对资源的访问控制特征：

package main

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

func main() {
   
	wg := sync.WaitGroup{
   }
	wg.Add(3)
	defer wg.Wait()

	var mutex sync.Mutex
	fmt.Println("Locking  (G0)")
	mutex.Lock()
	defer mutex.Unlock()
	fmt.Println("locked (G0)")

	for i := 1; i < 4; i++ {
   
		go func(i int) {
   
			fmt.Println("-----------------")
			fmt.Printf("Locking (G%d)\n", i)
			mutex.Lock()
			fmt.Printf("locked (G%d)\n", i)
			time.Sleep(time.Second * 2)
			mutex.Unlock()
			fmt.Printf("unlocked (G%d)\n", i)
			wg.Done()
			fmt.Println("++++++++++++++")
		}(i)
	}

	time.Sleep(time.Second * 2)
	fmt.Println("---ready unlock (G0)")
	fmt.Println("----unlocked (G0)")
}

输出：

Locking  (G0)
locked (G0)
-----------------
Locking (G3)
-----------------
Locking (G1)
-----------------
Locking (G2)
---ready unlock (G0)
----unlocked (G0)
locked (G3)
unlocked (G3)
++++++++++++++
locked (G1)
unlocked (G1)
locked (G2)
++++++++++++++
unlocked (G2)
++++++++++++++

通过程序执行结果我们可以看到，当有锁释放时，才能进行lock动作，G0锁释放时，才有后续锁释放的可能，这里是G1抢到释放机会。

Mutex也可以作为struct的一部分，这样这个struct就会防止被多线程更改数据。

package main

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

type Book struct {
   
	BookName string
	Lock     *sync.Mutex
}

func (bk *Book) SetName(wg *sync.WaitGroup, name string) {
   
	defer func() {
   
		fmt.Println("Unlock set name:", name)
		bk.Lock.Unlock()
		wg.Done()
	}()

	bk.Lock.Lock()
	fmt.Println("Lock set name:", name)
	time.Sleep(1 * time.Second)
	bk.BookName = name
}

func main() {
   
	wg := &sync.WaitGroup{
   }
	wg.Add(3)
	defer wg.Wait()

	var bk Book
	bk.Lock = &sync.Mutex{
   }
	books := []string{
   "《三国演义》", "《道德经》", "《西游记》"}
	for _, book := range books {
   
		go bk.SetName(wg, book)
	}
}

输出：

Lock set name: 《三国演义》
Unlock set name: 《三国演义》
Lock set name: 《西游记》
Unlock set name: 《西游记》
Lock set name: 《道德经》
Unlock set name: 《道德经》

读写锁

读写锁是分别针对读操作和写操作进行锁定和解锁操作的互斥锁。在Go语言中，读写锁由结构体类型sync.RWMutex代表。

基本遵循原则：

写锁定情况下，对读写锁进行读锁定或者写锁定，都将阻塞；而且读锁与写锁之间是互斥的；

读锁定情况下，对读写锁进行写锁定，将阻塞；加读锁时不会阻塞；

对未被写锁定的读写锁进行写解锁，会引发Panic；

对未被读锁定的读写锁进行读解锁的时候也会引发Panic；

写解锁在进行的同时会试图唤醒所有因进行读锁定而被阻塞的goroutine；

读解锁在进行的时候则会试图唤醒一个因进行写锁定而被阻塞的goroutine。

与互斥锁类似，sync.RWMutex类型的零值就已经是立即可用的读写锁了。在此类型的方法集合中包含了两对方法，即：

RWMutex提供四个方法：

func (*RWMutex) Lock // 写锁定
func (*RWMutex) Unlock // 写解锁

func (*RWMutex) RLock // 读锁定
func (*RWMutex) RUnlock // 读解锁

package main

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

var m *sync.RWMutex

func main() {
   
	wg := sync.WaitGroup{
   }
	wg.Add(20)
	var rwMutex sync.RWMutex
	Data := 0
	for i := 0; i < 10; i++ {
   
		go func(t int) {
   
			rwMutex.RLock()
			defer rwMutex.RUnlock()
			fmt.Printf("Read data: %v\n", Data)
			wg.Done()
			time.Sleep(1 * time.Second)
			// 这句代码第一次运行后，读解锁。
			// 循环到第二个时，读锁定后，这个goroutine就没有阻塞，同时读成功。
		}(i)

		go func(t int) {
   
			rwMutex.Lock()
			defer rwMutex.Unlock()
			Data += t
			fmt.Printf("Write Data: %v %d \n", Data, t)
			wg.Done()

			// 这句代码让写锁的效果显示出来，写锁定下是需要解锁后才能写的。
			time.Sleep(1 * time.Second)
		}(i)
	}
	time.Sleep(3 * time.Second)
	wg.Wait()
}

sync.WaitGroup

前面例子中我们有使用WaitGroup，它用于线程同步，WaitGroup等待一组线程集合完成，才会继续向下执行。主线程(goroutine)调用Add来设置等待的线程(goroutine)数量。然后每个线程(goroutine)运行，并在完成后调用Done。同时，Wait用来阻塞，直到所有线程(goroutine)完成才会向下执行。Add(-1)和Done()效果一致。

package main

import (
	"fmt"
	"sync"
)

func main() {
   
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
   
		wg.Add(1)
		go func(t int) {
   
			defer wg.Done()
			fmt.Println(t)
		}(i)
	}
	wg.Wait()
}

输出：

sync.Once

sync.Once.Do(f func())能保证once只执行一次,这个sync.Once块只会执行一次。

package main

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

var once sync.Once

func main() {
   
	arr := make([]string, 10)
	for i := 0; i < 10; i++ {
   
		once.Do(onces)
		go func(i int) {
   
			arr[i] = strconv.Itoa(i)
		}(i)
	}
	fmt.Println("arr:", arr)
	time.Sleep(4000)
}
func onces() {
   
	fmt.Println("onces")
}

输出：

onces
arr: [0 1 2 3 4 5 6 7 8 9]

sync.Map

随着Go1.9的发布，有了一个新的特性，那就是sync.map，它是原生支持并发安全的map。虽然说普通map并不是线程安全（或者说并发安全），但一般情况下我们还是使用它，因为这足够了；只有在涉及到线程安全，再考虑sync.map。

但由于sync.Map的读取并不是类型安全的，所以我们在使用Load读取数据的时候我们需要做类型转换。

sync.Map的使用上和map有较大差异，详情见代码。

package main

import (
	"fmt"
	"sync"
)

func main() {
   
	var m sync.Map
	//Store
	m.Store("name", "Joe")
	m.Store("gender", "Male")
	//LoadOrStore
	//若key不存在，则存入key和value，返回false和输入的value
	v, ok := m.LoadOrStore("name1", "Jim")
	fmt.Println(ok, v)           //false Jim
	fmt.Println(m.Load("name1")) //Jim true
	//若key已存在，则返回true和key对应的value，不会修改原来的value
	v, ok = m.LoadOrStore("name", "aaa")
	fmt.Println(ok, v) //true Joe
	//Load
	v, ok = m.Load("name")
	if ok {
   
		fmt.Println("key存在，值是： ", v)
	} else {
   
		fmt.Println("key不存在")
	}
	//Range
	//遍历sync.Map
	f := func(k, v interface{
   }) bool {
   
		fmt.Println(k, v)
		return true
	}
	m.Range(f)
	//Delete
	m.Delete("name1")
	fmt.Println(m.Load("name1"))
}

输出：

false Jim
true Joe
key存在，值是：  Joe
name Joe
gender Male
name1 Jim
<nil> false

24.指针和内存

指针

一个指针变量可以指向任何一个值的内存地址。它指向那个值的内存地址，在 32 位机器上占用 4 个字节，在 64 位机器上占用 8 个字节，并且与它所指向的值的大小无关。当然，可以声明指针指向任何类型的值来表明它的原始性或结构性；你可以在指针类型前面加上号（前缀）来获取指针所指向的内容，这里的号是一个类型更改器。使用一个指针引用一个值被称为间接引用。

当一个指针被定义后没有分配到任何变量时，它的值为 nil。

一个指针变量通常缩写为 ptr。

符号 “*” 可以放在一个指针前，如 “*intP”，那么它将得到这个指针指向地址上所存储的值；这被称为反引用（或者内容或者间接引用）操作符；另一种说法是指针转移。

对于任何一个变量 var，如下表达式都是正确的：var == *(&var)

注意事项：
你不能得到一个数字或常量的地址，下面的写法是错误的。

package main

import "fmt"

func main() {
   
	var i = 5
	ptr := &i // 0xc00000a098
	fmt.Println(ptr)
	ptr2 := *ptr // 5
	fmt.Println(ptr2)
}

所以说，Go 语言和 C、C++ 以及 D 语言这些低级（系统）语言一样，都有指针的概念。

但是对于经常导致 C 语言内存泄漏继而程序崩溃的指针运算（所谓的指针算法，如：pointer+2，移动指针指向字符串的字节数或数组的某个位置）是不被允许的。

Go 语言中的指针保证了内存安全，更像是 Java、C# 和 VB.NET 中的引用。

因此 c = *p++ 在 Go 语言的代码中是不合法的。

指针的一个高级应用是你可以传递一个变量的引用（如函数的参数），这样不会传递变量的拷贝。指针传递是很廉价的，只占用 4 个或 8 个字节。当程序在工作中需要占用大量的内存，或很多变量，或者两者都有，使用指针会减少内存占用和提高效率。被指向的变量也保存在内存中，直到没有任何指针指向它们，所以从它们被创建开始就具有相互独立的生命周期。

另一方面（虽然不太可能），由于一个指针导致的间接引用（一个进程执行了另一个地址），指针的过度频繁使用也会导致性能下降。

指针也可以指向另一个指针，并且可以进行任意深度的嵌套，导致你可以有多级的间接引用，但在大多数情况这会使你的代码结构不清晰。

如我们所见，在大多数情况下 Go 语言可以使程序员轻松创建指针，并且隐藏间接引用，如：自动反向引用。

对一个空指针的反向引用是不合法的，并且会使程序崩溃：

package main

func main() {
   
	var p *int = nil
	*p = 0
}

panic: runtime error: invalid memory address or nil pointer dereference

指针的使用方法：

定义指针变量；

为指针变量赋值；

访问指针变量中指向地址的值；

在指针类型前面加上*号来获取指针所指向的内容。

package main

import "fmt"

func main() {
   
	var a, b = 20, 30 // 声明实际变量
	var ptra *int     // 声明指针变量
	var ptrb = &b
	ptra = &a // 指针变量的存储地址
	fmt.Printf("a  变量的地址是: %x\n", &a) //a  变量的地址是: c00000a098
	fmt.Printf("b  变量的地址是: %x\n", &b) //b  变量的地址是: c00000a0b0

	// 指针变量的存储地址
	fmt.Printf("ptra  变量的存储地址: %x\n", ptra)//ptra  变量的存储地址: c00000a098
	fmt.Printf("ptrb  变量的存储地址: %x\n", ptrb)//ptrb  变量的存储地址: c00000a0b0

	// 使用指针访问值
	fmt.Printf("*ptra  变量的值: %d\n", *ptra)//*ptra  变量的值: 20
	fmt.Printf("*ptrb  变量的值: %d\n", *ptrb)//*ptrb  变量的值: 30
}

new() 和 make() 的区别

看起来二者没有什么区别，都在堆上分配内存，但是它们的行为不同，适用于不同的类型。

new(T) 为每个新的类型T分配一片内存，初始化为 0 并且返回类型*T的内存地址：这种方法返回一个指向类型为 T，值为 0 的地址的指针，它适用于值类型如数组和结构体；它相当于 &T{}。
make(T) 返回一个类型为 T 的初始值，它只适用于3种内建的引用类型：切片、map 和 channel。

你并不总是知道变量是分配到栈还是堆上。在C++中，使用new创建的变量总是在堆上。在Go中，即使是使用 new() 或者 make() 函数来分配，变量的位置还是由编译器决定。编译器根据变量的大小和泄露分析的结果来决定其位置。这也意味着在局部变量上返回引用是没问题的，而这在C或者C++这样的语言中是不行的。

如果你想知道变量分配的位置，在"go build"或"go run"上传入"-m" “-gcflags”（即，go run -gcflags -m app.go）。

垃圾回收和 SetFinalizer

Go 语言开发者一般不需要写代码来释放不再使用的变量或结构体占用的内存，在 Go语言运行时有一个独立的进程，即垃圾收集器（GC），会专门处理这些事情，它搜索不再使用的变量然后释放它们占用的内存，这是自动垃圾回收；还有一种是主动垃圾回收，通过显式调用 runtime.GC()来实现。

通过调用 runtime.GC() 函数可以显式的触发 GC，这在某些的场景下非常有用，比如当内存资源不足时调用 runtime.GC()，它会在此函数执行的点上立即释放一大片内存，但此时程序可能会有短时的性能下降（因为 GC 进程在执行）。

下面代码中的func (p *Person) NewOpen()在某些情况下非常有必要这样处理，比如某些资源占用申请，开发人员可能忘记使用defer Close()来销毁处理，但通过SetFinalizer，如果GC自动运行或者手动运行GC，则都能及时销毁这些资源，释放占用的内存而避免内存泄漏。

GC过程中重要的函数func SetFinalizer(obj interface{}, finalizer interface{})有两个参数，参数一：obj必须是指针类型。参数二：finalizer是一个函数，其参数类型是obj的类型，其没有返回值。

package main

import (
	"log"
	"runtime"
	"time"
)

type Person struct {
   
	Name string
	Age  int
}

func (p *Person) Close() {
   
	p.Name = "NewName"
	log.Println(p)
	log.Println("Close")
}

func (p *Person) NewOpen() {
   
	log.Println("Init")
	runtime.SetFinalizer(p, (*Person).Close)
}

func Tt(p *Person) {
   
	p.Name = "NewName"
	log.Println(p)
	log.Println("Tt")
}

// Mem 查看内存情况
func Mem(m *runtime.MemStats) {
   
	runtime.ReadMemStats(m)
	log.Printf("%d Kb\n", m.Alloc/1024)
}

func main() {
   
	var m runtime.MemStats
	Mem(&m)

	var p = &Person{
   Name: "lee", Age: 4}
	p.NewOpen()
	log.Println("Gc完成第一次")
	log.Println("p:", p)
	runtime.GC()
	time.Sleep(time.Second * 2)
	Mem(&m)

	var p1 = &Person{
   Name: "Goo", Age: 9}
	runtime.SetFinalizer(p1, Tt)
	log.Println("Gc完成第二次")
	time.Sleep(time.Second * 2)
	runtime.GC()
	time.Sleep(time.Second * 2)
	Mem(&m)
}

输出：

2024/04/09 13:33:14 75 Kb
2024/04/09 13:33:14 Init
2024/04/09 13:33:14 Gc完成第一次
2024/04/09 13:33:14 p: &{
   lee 4}
2024/04/09 13:33:14 &{
   NewName 4}
2024/04/09 13:33:14 Close