Go语言上手（二） | 青训营笔记

最新推荐文章于 2024-05-08 15:59:38 发布

只会复制粘贴的

最新推荐文章于 2024-05-08 15:59:38 发布

阅读量68

点赞数

文章标签： golang 笔记

本文链接：https://blog.csdn.net/weixin_54558860/article/details/130319605

版权

本堂课重点内容：

GO的并发
GO的依赖管理
Go的测试
GO的包管理
Go的web项目

知识点

GO的并发编程

Go语言的优势与特点

简单的协程示例

package main

import (
	"fmt"
	"time"
)

func hello(i int) {
	fmt.Println("hello go:", i)
}
func main() {  
	for i := 0; i < 5; i++ {
		go func(j int) {
			hello(j)
		}(i)
	}
	time.Sleep(time.Second)
}

Channel：

make(chan 元素类型，[缓冲大小])

Lock

就是一把锁，可以解决多线程下资源的同步问题

//Mutex 是互斥锁，零值是解锁的互斥锁，首次使用后不得复制互斥锁。也就是题目中的锁

如果对一个已经上锁的对象再次上锁，那么就会导致该锁定操作被阻塞，直到该互斥锁回到被解锁状态

基本使用如下

xxx.lock()

代码

xxx.unlock()

Go语言还有读写锁，用途更加专业

而其实当我们对一个固定的资源只做“读”操作的话，是不存在资源竞争的问题的，也就不会引发竞态。因为数据是不变的，不管怎么读取，多少goroutine同时读取都没有问题。

package main

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

//全局变量
var end int
var rLock sync.RWMutex

func Read(i int) {
    rLock.RLock()
    fmt.Printf("读 goroutine%d 结果:%d\n", i, end)
    defer rLock.RUnlock()
}

func Write(i int) {
    rLock.Lock()
    end = end + i
    fmt.Printf("写 goroutine%d 结果:%d\n", i, end)
    defer rLock.Unlock()
}

func main() {
    for i := 0; i < 5; i++ {
        go Write(i)
    }
    for i := 0; i < 5; i++ {
        go Read(i)
    }
    time.Sleep(time.Second * 120)
}

结果如下

写 goroutine0 结果:0
读 goroutine1 结果:0
读 goroutine0 结果:0
读 goroutine2 结果:0
读 goroutine3 结果:0
读 goroutine4 结果:0
写 goroutine2 结果:2
写 goroutine1 结果:3
写 goroutine3 结果:6
写 goroutine4 结果:10

可以看出当所有的读取之后才会进入写的状态

第一个写入是因为程序还未运行读的线程

WaitGroup

Go语言中除了可以使用**通道（channel）**和互斥锁进行两个并发程序间的同步外，还可以使用等待组进行多个任务的同步，等待组可以保证在并发环境中完成指定数量的任务

WaitGroup的用途是使得主线程一直阻塞等待直到所有相关的子goroutine都已经完成了任务。

在 sync.WaitGroup（等待组）类型中，每个 sync.WaitGroup 值在内部维护着一个计数，此计数的初始默认值为零。

等待组有下面几个方法可用，如下表所示。

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            println("hello")
        }()
    }
    wg.Wait()
}