Golang-并发编程原理解析

go并发编程

一.背景知识介绍

1.进程和线程

  • 进程是程序在操作系统中一次执行的过程,系统进行资源分配和调度的基本单位
  • 线程是进程的一个执行实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位
  • 一个进程可以创建和撤销多个线程,同一个进程中的多个线程之间可以并发执行

2.并发和并行

  • 多线程程序在单核CPU上运行,就是并发
  • 多线程程序在多核CPU上运行,就是并行
  • 并发不是并行,并发主要是由切换时间片来实现同时运行,并行则是直接利用多核实现多线程的运行,go可以设置使用的核数,以发挥多核计算机的能力

Golang-并发编程原理解析_第1张图片

Golang-并发编程原理解析_第2张图片

3.协程和线程

  • 协程:独立的栈空间,共享堆空间,调度由用户自己控制,本质上有点类似于用户级线程,这些用户级线程的调度也是自己实现的
  • 线程,一个线程上可以跑多个协程,协程是轻量级的线程

4.goroutine

  • 每个goroutine实例只有4-5KB的内存占用(可伸缩),和由于实现机制而大幅度减少的创建和销毁开销是go高并发的根本原因
  • goroutine 奉行通过通信来共享内存,而不是通过共享内存来通信

二.Channel

  • Go语言的并发模型是CSP,提倡通过通信来进行内存共享,而不是通过共享内存来实现通信
  • goroutine是Go程序并发的实体,channel就是他们之间的连接,channel是可以让一个goroutine发送特定值到另一个goroutine的通信机制
  • Go语言中的channel是一种特殊的类型,channel像是一个传送带或者队列,总是遵循FIFO先入先出的原则,保证收发数据的顺序
  • 每一个Channel都有其具体的传输数据类型,也就是说声明的需要为其指定元素类型
  • 声明的Channel需要make初始化之后才能使用
  • 声明并初始化channel
    ch := make(chan int)

1.channle的操作

channel有三种操作,接收,发送,关闭。发送和接收都使用 <- 符号

  • 接收
x := <- ch // 从ch中接收值并赋值给变量x
  • 发送
ch <- 10 // 把10发送到ch中
  • 关闭
close(ch)

注意事项:

  • 关于关闭通道,只有在需要通知接收方的goroutine,所有的数据都已经发送完毕的时候,才需要关闭通道,也就是说,关闭通道,可以告诉接收方的goroutine,所有的数据都已经发送完毕了
  • 通道是可以被GC回收的,关闭通道不是必须的,不像文件那样,在结束操作后必须关闭文件
  • 对一个关闭的通道,再发送数据,就会导致panic
  • 对一个关闭的通道进行接收会一直获取值,直到通道为空为止
  • 对一个关闭的,并且没有值的通道,进行接收操作,会得到对应类型的零值
  • 关闭一个已经关闭的通道会导致panic

2.无缓冲的Channel

  • 无缓冲通道,又叫做阻塞通道

Golang-并发编程原理解析_第3张图片

  • 无缓冲通道只有在有人接收值的时候才能发送值,否则就会一直阻塞住,同样的,只有在有人发送值的时候,才能接收值
func main() {
    ch := make(chan int)
    ch <- 10
    fmt.Println("发送成功")
    
    // fatal error: all goroutines are asleep - deadlock!
}
func recv(c chan int) {
    ret := <-c
    fmt.Println("接收成功", ret)
}
func main() {
    ch := make(chan int)
    go recv(ch) // 启用goroutine从通道接收值
    ch <- 10
    fmt.Println("发送成功")
}
  • 使用无缓冲通道进行通信将导致发送和接收的goroutine同步化,因此,无缓冲通道也被称为同步通道

3.有缓冲的Channel

  • 在通道使用make函数初始化的时候可以指定缓冲容量
ch := make(chan int, 10) // 创建一个容量为10的有缓冲区通道

Golang-并发编程原理解析_第4张图片

  • 只要通道的容量大于0,那么该通道就是有缓冲通道
  • 通道的容量表示通道中能最多存放元素的数量
  • 通过len函数获取当前通道内元素数量,通过cap函数获取通道的容量

4.单向channel

  • 限制通道在函数中只能发送或者接收
  • chan <- int是一个只能发送的通道,可以发送但是不能接收;
  • <-chan int是一个只能接收的通道,可以接收但是不能发送。
  • 在函数传参以及任何赋值操作中,将双向通道转为单向通道是可以的,但反过来不行
func counter(out chan<- int) {
    for i := 0; i < 100; i++ {
        out <- i
    }
    close(out)
}

func squarer(out chan<- int, in <-chan int) {
    for i := range in {
        out <- i * i
    }
    close(out)
}
func printer(in <-chan int) {
    for i := range in {
        fmt.Println(i)
    }
}

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    go counter(ch1)
    go squarer(ch2, ch1)
    printer(ch2)
}

5.优雅的从通道循环取值

  • 通过通道发送有限的数据时,可以通过close函数关闭通道来告知接收该通道值的goroutine停止等待
  • 当通道关闭时,再往该通道发送值会导致panic,并且从该通道接收到值,全部接收完了之后再接收的话,会接收到类型零值
  • 那我们应该如何判断通道被关闭了呢?有下面两种方法可供参考
func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    // 开启goroutine将0~100的数发送到ch1中
    go func() {
        for i := 0; i < 100; i++ {
            ch1 <- i
        }
        close(ch1)
    }()
    // 开启goroutine从ch1中接收值,并将该值的平方发送到ch2中
    go func() {
        for {
            i, ok := <-ch1 // 通道关闭后再取值ok=false
            if !ok {
                break
            }
            ch2 <- i * i
        }
        close(ch2)
    }()
    // 在主goroutine中从ch2中接收值打印
    for i := range ch2 { // 通道关闭后会退出for range循环
        fmt.Println(i)
    }
}

6.channel异常情况总结

Golang-并发编程原理解析_第5张图片

三.select多路复用

  • 在某些场景下,我们需要从多个通道接收数据,通道在接收数据时,如果没有数据可以接收得阻塞住,等待数据过来,为了应对这种场景,GO内置了select关键字,可以同时响应多个通道的操作
  • go select的思想来源于网络IO模型中的select,本质上也是IO多路复用,只不过这里的IO是基于channel而不是基于网络
  • select的使用类似switch,有一系列case和default,每个case对应一个通道的接收或发送过程
select {
    case <-chan1:
       // 如果chan1成功读到数据,则进行该case处理语句
    case chan2 <- 1:
       // 如果成功向chan2写入数据,则进行该case处理语句
    default:
       // 如果上面都没有成功,则进入default处理流程
    }
  • select会一直等待,直到某个case的通信操作完成时,就会执行case分支对应的语句
  • select可以同时监听多个channel,直到其中一个channel 就绪,如果多个channel同时就绪,则随机选择一个执行
  • select可以用来判断管道是否已满,比如仅有一个case和default,该case是往管道写,当管道满了之后,该case会失败,因仅有一个case,所以会走default,那就可以在default中通知该通道已满
package main

import (
	"fmt"
	"time"
)

// 判断管道有没有存满
func main() {
	// 创建管道
	output1 := make(chan string, 10)
	// 子协程写数据
	go write(output1)
	// 取数据
	for s := range output1 {
		fmt.Println("res:", s)
		time.Sleep(time.Second)
	}
}

func write(ch chan string) {
	for {
		select {
		// 写数据
		case ch <- "hello":
			fmt.Println("write hello")
		default:  // 因为通道满了,往执行不了写数据了,就会走default
			fmt.Println("channel full")
		}
		time.Sleep(time.Millisecond * 500)
	}
}

四.goroutine池

  • 本质是生产者消费者模型
  • 可以有效的控制goroutine数量,防止暴涨
  • 需求:
    • 计算一个数字的各个数位之和,例如数字123,结果是1+2+3=6
    • 随机生成数字进行计算
package main

import (
    "fmt"
    "math/rand"
)

type Job struct {
    // id
    Id int
    // 需要计算的随机数
    RandNum int
}

type Result struct {
    // 这里必须传对象实例
    job *Job
    // 求和
    sum int
}

func main() {
    // 需要2个管道
    // 1.job管道
    jobChan := make(chan *Job, 128)
    // 2.结果管道
    resultChan := make(chan *Result, 128)
    // 3.创建工作池
    createPool(64, jobChan, resultChan)
    // 4.开个打印的协程
    go func(resultChan chan *Result) {
        // 遍历结果管道打印
        for result := range resultChan {
            fmt.Printf("job id:%v randnum:%v result:%d\n", result.job.Id,
                result.job.RandNum, result.sum)
        }
    }(resultChan)
    var id int
    // 循环创建job,输入到管道
    for {
        id++
        // 生成随机数
        r_num := rand.Int()
        job := &Job{
            Id:      id,
            RandNum: r_num,
        }
        jobChan <- job
    }
}

// 创建工作池
// 参数1:开几个协程
func createPool(num int, jobChan chan *Job, resultChan chan *Result) {
    // 根据开协程个数,去跑运行
    for i := 0; i < num; i++ {
        go func(jobChan chan *Job, resultChan chan *Result) {
            // 执行运算
            // 遍历job管道所有数据,进行相加
            for job := range jobChan {
                // 随机数接过来
                r_num := job.RandNum
                // 随机数每一位相加
                // 定义返回值
                var sum int
                for r_num != 0 {
                    tmp := r_num % 10
                    sum += tmp
                    r_num /= 10
                }
                // 想要的结果是Result
                r := &Result{
                    job: job,
                    sum: sum,
                }
                //运算结果扔到管道
                resultChan <- r
            }
        }(jobChan, resultChan)
    }
}

五.并发安全和锁

  • 当多个goroutine操作同一个临界区的资源时,可能会有数据竞态问题,导致非预期结果

样例如下,我们启动两个goroutine去累加x的值,但这两个goroutine访问x时会存在数据竞争

var x int64
var wg sync.WaitGroup

func add() {
    for i := 0; i < 5000; i++ {
        x = x + 1
    }
    wg.Done()
}
func main() {
    wg.Add(2)
    go add()
    go add()
    wg.Wait()
    fmt.Println(x)
}

1.互斥锁

  • 互斥锁是一种常用的控制共享资源访问的方法
  • Go语言中使用sync包的Mutex类型来实现互斥锁
  • 使用互斥锁可以保证同一时间有且只有一个goroutine进入临界区,其他goroutine则在等待锁
  • 当互斥锁释放后,等待的goroutine才可以获取锁进入临界区
  • 多个goroutine同时等待一个锁时,唤醒的策略是随机的
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)
}

2.读写锁

  • 很多场景下是读多写少的,当我们并发去读取一个资源不涉及资源修改时,完全没有必要使用互斥锁,因为互斥锁是完全互斥的
  • 读多写少的情况下,使用读写锁是一个更好的选择
  • Go语言中使用sync包的RWMutex来实现读写锁
  • 读写锁分为两种:读锁和写锁
  • 当一个goroutine获取读锁之后,其他的goroutine如果是获取读锁则会获得读锁,如果是获取写锁就会等待
  • 当一个goroutine获取写锁之后,其他的goroutine无论是获取读锁还是获取写锁,都会等待
  • 读写锁非常适合读多写少的场景,如果读和写差别不大,则读写锁的优势就发挥不出来

样例如下:

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))
}

3.sync.Map

  • Go语言中内置的map并不是并发安全的

样例如下:

var m = make(map[string]int)

func get(key string) int {
	return m[key]
}

func set(key string, value int) {
	m[key] = value
}

func main() {
	wg := sync.WaitGroup{}
	for i := 0; i < 20; i++ {
		wg.Add(1)
		go func(n int) {
			key := strconv.Itoa(n)
			set(key, n)
			fmt.Printf("k=:%v,v:=%v\n", key, get(key))
			wg.Done()
		}(i)
	}
	wg.Wait()
	
	// fatal error: concurrent map writes
}
  • Go语言的sync包中提供了一个开箱即用的并发安全版Map,sync.Map,开箱即用表示不用像内置的Map一样使用make函数初始化就能用,同时sync.Map内置了诸如Store,Load,LoadOrStore,Delete,Range等操作方法。
var m = sync.Map{}

func main() {
    wg := sync.WaitGroup{}
    for i := 0; i < 20; i++ {
        wg.Add(1)
        go func(n int) {
            key := strconv.Itoa(n)
            m.Store(key, n)
            value, _ := m.Load(key)
            fmt.Printf("k=:%v,v:=%v\n", key, value)
            wg.Done()
        }(i)
    }
    wg.Wait()
}

六.并发同步

  • Go语言中使用sync包的WaitGroup来实现并发任务的同步

1.sync.WaitGroup

sync.WaitGroup有以下三种方法:

  • (wg * WaitGroup) Add(delta int) : 计数器 + delta
  • (wg *WaitGroup) Done() : 计数器-1
  • (wg *WaitGroup) Wait() : 阻塞知道计数器变为0

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()
}

2.sync.Once

  • 很多场景下,我们需要确保某些操作在高并发时只执行一次,例如只加载一次配置文件
  • Go语言中的sync包提供了一个针对只执行一次场景的解决方案-sync.Once
  • sync.Once只有一个Do方法,Do(f func())

样例如下:

  • 延迟一个开销很大的初始化操作到真正用到它的时候再执行
var icons map[string]image.Image

var loadIconsOnce sync.Once

func loadIcons() {
    icons = map[string]image.Image{
        "left":  loadIcon("left.png"),
        "up":    loadIcon("up.png"),
        "right": loadIcon("right.png"),
        "down":  loadIcon("down.png"),
    }
}

// Icon 是并发安全的
func Icon(name string) image.Image {
    loadIconsOnce.Do(loadIcons)
    return icons[name]
}

sync.Once内部包含一个互斥锁和一个布尔值,互斥锁保证布尔值和数据的安全,而布尔值用来记录初始化是否完成,这样设计就能保证初始化操作的时候是并发安全的,并且初始化操作也不会执行多次

七.原子操作

  • 代码中加锁操作因为设计到内核态的上下文切换,耗时比较高,代价也大
  • 针对基本数据类型我们可以使用原子操作来保证并发安全
  • Go语言中原子操作由内置的标准库sync/atomic提供

样例如下:

  • 比较互斥锁和原子操作的性能
var x int64
var l sync.Mutex
var wg sync.WaitGroup

// 普通版加函数
func add() {
    // x = x + 1
    x++ // 等价于上面的操作
    wg.Done()
}

// 互斥锁版加函数
func mutexAdd() {
    l.Lock()
    x++
    l.Unlock()
    wg.Done()
}

// 原子操作版加函数
func atomicAdd() {
    atomic.AddInt64(&x, 1)
    wg.Done()
}

func main() {
    start := time.Now()
    for i := 0; i < 10000; i++ {
        wg.Add(1)
        // go add()       // 普通版add函数 不是并发安全的
        // go mutexAdd()  // 加锁版add函数 是并发安全的,但是加锁性能开销大
        go atomicAdd() // 原子操作版add函数 是并发安全,性能优于加锁版
    }
    wg.Wait()
    end := time.Now()
    fmt.Println(x)
    fmt.Println(end.Sub(start))
}
  • atomic包提供了底层的原子级内存操作,对于同步算法的实现很有帮助,但是除了某些特殊的底层应用,使用通道或者sync包实现同步更好!

八.总结

Go语言的并发模型是CSP,提倡通过通信来进行内存共享,而不是通过共享内存来实现通信

你可能感兴趣的:(python,多线程,java,数据库,编程语言)