Go并发编程详解

概述

        简而言之,所谓并发编程是指在一台处理器上“同时”处理多个任务。

        随着硬件的发展,并发程序变得越来越重要。Web服务器会一次处理成千上万的请求。平板电脑和手机app在渲染用户画面同时还会后台执行各种计算任务和网络请求。即使是传统的批处理问题--读取数据,计算,写输出--现在也会用并发来隐藏掉I/O的操作延迟以充分利用现代计算机设备的多个核心。计算机的性能每年都在以非线性的速度增长。

        宏观的并发是指在一段时间内,有多个程序在同时运行。

        并发在微观上,是指在同一时刻只能有一条指令执行,但多个程序指令被快速的轮换执行,使得在宏观上具有多个进程同时执行的效果,但在微观上并不是同时执行的,只是把时间分成若干段,使多个程序快速交替的执行。

Go并发编程详解_第1张图片

并行和并发

        并行(parallel):指在同一时刻,有多条指令在多个处理器上同时执行。

Go并发编程详解_第2张图片

        并发(concurrency):指在同一时刻只能有一条指令执行,但多个进程指令被快速的轮换执行,使得在宏观上具有多个进程同时执行的效果,但在微观上并不是同时执行的,只是把时间分成若干段,通过cpu时间片轮转使多个进程快速交替的执行。

Go并发编程详解_第3张图片

以咖啡机的例子来解释并行和并发的区别。 

Go并发编程详解_第4张图片

 

  1. 并行是两个队列同时使用两台咖啡机 (真正的多任务)
  2. 并发是两个队列交替使用一台咖啡机 ( 假 的多任务)

 

常见并发编程技术 

进程并发 

程序和进程 

        程序,是指编译好的二进制文件,在磁盘上,不占用系统资源(cpu、内存、打开的文件、设备、锁....)

        进程,是一个抽象的概念,与操作系统原理联系紧密。进程是活跃的程序,占用系统资源。在内存中执行。(程序运行起来,产生一个进程)

        程序 → 剧本(纸)          进程 → 戏(舞台、演员、灯光、道具...)

        同一个剧本可以在多个舞台同时上演。同样,同一个程序也可以加载为不同的进程(彼此之间互不影响)

        如:同时开两个终端。各自都有一个bash但彼此ID不同。

        在windows系统下,通过查看“任务管理器”,可以查看相应的进程。包括我们在基础班写的“飞机大战”等程序,运行起来后也可以在“任务管理器”中查看到。运行起来的程序就是一个进程。如下图所示:

 

进程状态

        进程基本的状态有5种。分别为初始态,就绪态,运行态,挂起态与终止态。其中初始态为进程准备阶段,常与就绪态结合来看。

Go并发编程详解_第5张图片

 

进程并发

在使用进程 实现并发时会出现什么问题呢?

 1:系统开销比较大,占用资源比较多,开启进程数量比较少。

 2:在unix/linux系统下,还会产生“孤儿进程”和“僵尸进程”。

        通过前面查看操作系统的进程信息,我们知道在操作系统中,可以产生很多的进程。在unix/linux系统中,正常情况下,子进程是通过父进程fork创建的,子进程再创建新的进程。

        并且父进程永远无法预测子进程 到底什么时候结束。 当一个 进程完成它的工作终止之后,它的父进程需要调用系统调用取得子进程的终止状态。

孤儿进程

        孤儿进程: 父进程先于子进程结束,则子进程成为孤儿进程,子进程的父进程成为init进程,称为init进程领养孤儿进程。

僵尸进程

        僵尸进程: 进程终止,父进程尚未回收,子进程残留资源(PCB)存放于内核中,变成僵尸(Zombie)进程。 

        Windows下的进程和Linux下的进程是不一样的,它比较懒惰,从来不执行任何东西,只是为线程提供执行环境。然后由线程负责执行包含在进程的地址空间中的代码。当创建一个进程的时候,操作系统会自动创建这个进程的第一个线程,成为主线程。

线程并发

什么是线程

LWP:light weight process 轻量级的进程,本质仍是进程 (Linux下)

Go并发编程详解_第6张图片

        进程:独立地址空间,拥有PCB

        线程:有独立的PCB,但没有独立的地址空间(共享)

        区别:在于是否共享地址空间。独居(进程);合租(线程)。

                线程:最小的执行单位

                 进程:最小分配资源单位,可看成是只有一个线程的进程。

        Windows系统下,可以直接忽略进程的概念,只谈线程。因为线程是最小的执行单位,是被系统独立调度和分派的基本单位。而进程只是给线程提供执行环境。

线程同步

        同步即协同步调,按预定的先后次序运行。

        线程同步,指一个线程发出某一功能调用时,在没有得到结果之前,该调用不返回。同时其它线程为保证数据一致性,不能调用该功能。

        举例1: 银行存款 5000。柜台,折:取3000;提款机,卡:取 3000。剩余:2000

        举例2: 内存中100字节,线程T1欲填入全1, 线程T2欲填入全0。但如果T1执行了50个字节失去cpu,T2执行,会将T1写过的内容覆盖。当T1再次获得cpu继续   从失去cpu的位置向后写入1,当执行结束,内存中的100字节,既不是全1,也不是全0。

        产生的现象叫做“与时间有关的错误”(time related)。为了避免这种数据混乱,线程需要同步。

        “同步”的目的,是为了避免数据混乱,解决与时间有关的错误。实际上,不仅线程间需要同步,进程间、信号间等等都需要同步机制。

        因此,所有“多个控制流,共同操作一个共享资源”的情况,都需要同步。

锁的应用

互斥量mutex

        Linux中提供一把互斥锁mutex(也称之为互斥量)。

        每个线程在对资源操作前都尝试先加锁,成功加锁才能操作,操作结束解锁。

        资源还是共享的,线程间也还是竞争的,                                                         

        但通过“锁”就将资源的访问变成互斥操作,而后与时间有关的错误也不会再产生了。

Go并发编程详解_第7张图片

 

但,应注意:同一时刻,只能有一个线程持有该锁。

        当A线程对某个全局变量加锁访问,B在访问前尝试加锁,拿不到锁,B阻塞。C线程不去加锁,而直接访问该全局变量,依然能够访问,但会出现数据混乱。

        所以,互斥锁实质上是操作系统提供的一把“建议锁”(又称“协同锁”),建议程序中有多线程访问共享资源的时候使用该机制。但,并没有强制限定。

        因此,即使有了mutex,如果有线程不按规则来访问数据,依然会造成数据混乱。

读写锁

与互斥量类似,但读写锁允许更高的并行性。其特性为:写独占,读共享。

  1. 读写锁状态:

特别强调:读写锁只有一把,但其具备两种状态:

        1. 读模式下加锁状态 (读锁)

        2. 写模式下加锁状态 (写锁)

  1. 读写锁特性:  
  1. 读写锁是“写模式加锁”时, 解锁前,所有对该锁加锁的线程都会被阻塞。
  2. 读写锁是“读模式加锁”时, 如果线程以读模式对其加锁会成功;如果线程以写模式加锁会阻塞。
  3. 读写锁是“读模式加锁”时, 既有试图以写模式加锁的线程,也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞,写锁优先级高

        读写锁也叫共享-独占锁。当读写锁以读模式锁住时,它是以共享模式锁住的;当它以写模式锁住时,它是以独占模式锁住的。写独占、读共享。

        读写锁非常适合于对数据结构读的次数远大于写的情况。

协程并发

        协程:coroutine。也叫轻量级线程。

        与传统的系统级线程和进程相比,协程最大的优势在于“轻量级”。可以轻松创建上万个而不会导致系统资源衰竭。而线程和进程通常很难超过1万个。这也是协程别称“轻量级线程”的原因。

一个线程中可以有任意多个协程,但某一时刻只能有一个协程在运行,多个协程分享该线程分配到的计算机资源

        多数语言在语法层面并不直接支持协程,而是通过库的方式支持,但用库的方式支持的功能也并不完整,比如仅仅提供协程的创建、销毁与切换等能力。如果在这样的轻量级线程中调用一个同步 IO 操作,比如网络通信、本地文件读写,都会阻塞其他的并发执行轻量级线程,从而无法真正达到轻量级线程本身期望达到的目标。

        在协程中,调用一个任务就像调用一个函数一样,消耗的系统资源最少!但能达到进程、线程并发相同的效果。

        在一次并发任务中,进程、线程、协程均可以实现。从系统资源消耗的角度出发来看,进程相当多,线程次之,协程最少。   

Go并发

        Go 在语言级别支持协程,叫goroutine。Go 语言标准库提供的所有系统调用操作(包括所有同步IO操作),都会出让CPU给其他goroutine。这让轻量级线程的切换管理不依赖于系统的线程和进程,也不需要依赖于CPU的核心数量。

        有人把Go比作21世纪的C语言。第一是因为Go语言设计简单,第二,21世纪最重要的就是并行程序设计,而Go从语言层面就支持并行。同时,并发程序的内存管理有时候是非常复杂的,而Go语言提供了自动垃圾回收机制。

        Go语言为并发编程而内置的上层API基于顺序通信进程模型CSP(communicating sequential processes)。这就意味着显式锁都是可以避免的,因为Go通过相对安全的通道发送和接受数据以实现同步,这大大地简化了并发程序的编写。

        Go语言中的并发程序主要使用两种手段来实现。goroutine和channel。

Goroutine

什么是Goroutine

        goroutine是Go并行设计的核心。goroutine说到底其实就是协程,它比线程更小,十几个goroutine可能体现在底层就是五六个线程,Go语言内部帮你实现了这些goroutine之间的内存共享。执行goroutine只需极少的栈内存(大概是4~5KB),当然会根据相应的数据伸缩。也正因为如此,可同时运行成千上万个并发任务。goroutine比thread更易用、更高效、更轻便。

        一般情况下,一个普通计算机跑几十个线程就有点负载过大了,但是同样的机器却可以轻松地让成百上千个goroutine进行资源竞争。

Goroutine的创建

        只需在函数调⽤语句前添加 go 关键字,就可创建并发执⾏单元。开发⼈员无需了解任何执⾏细节,调度器会自动将其安排到合适的系统线程上执行。

        在并发编程中,我们通常想将一个过程切分成几块,然后让每个goroutine各自负责一块工作,当一个程序启动时,主函数在一个单独的goroutine中运行,我们叫它main goroutine。新的goroutine会用go语句来创建。而go语言的并发设计,让我们很轻松就可以达成这一目的。

示例代码:

package main

import (
    "fmt"
    "time"
)

func newTask() {
    i := 0
    for {
        i++
        fmt.Printf("new goroutine: i = %d\n", i)
        time.Sleep(1 * time.Second) //延时1s
    }
}

func main() {
    //创建一个 goroutine,启动另外一个任务
    go newTask()
    i := 0
    //main goroutine 循环打印
    for {
        i++
        fmt.Printf("main goroutine: i = %d\n", i)
        time.Sleep(1 * time.Second) //延时1s
    }
}

程序运行结果:

Go并发编程详解_第8张图片

 

Goroutine特性

        主goroutine退出后,其它的工作goroutine也会自动退出:

package main

import (
"fmt"
"time"
)

func newTask() {
    i := 0
    for {
        i++
        fmt.Printf("new goroutine: i = %d\n", i)
        time.Sleep(1 * time.Second) //延时1s
    }
}

func main() {
    //创建一个 goroutine,启动另外一个任务
    go newTask()

    fmt.Println("main goroutine exit")
}

程序运行结果:

 

runtime包

Gosched

        runtime.Gosched() 用于让出CPU时间片,让出当前goroutine的执行权限,调度器安排其他等待的任务运行,并在下次再获得cpu时间轮片的时候,从该出让cpu的位置恢复执行。

        有点像跑接力赛,A跑了一会碰到代码runtime.Gosched() 就把接力棒交给B了,A歇着了,B继续跑。

示例代码:

package main

import (
"fmt"
"runtime"
)

func main() {
    //创建一个goroutine
    go func(s string) {
        for i := 0; i < 2; i++ {
            fmt.Println(s)
        }
    }("world")

    for i := 0; i < 2; i++ {
        runtime.Gosched()  //import "runtime" 包
        /*
            屏蔽runtime.Gosched()运行结果如下:
                hello
                hello

            没有runtime.Gosched()运行结果如下:
                world
                world
                hello
                hello
        */
        fmt.Println("hello")
    }
}

以上程序的执行过程如下:

        主协程进入main()函数,进行代码的执行。当执行到go func()匿名函数时,创建一个新的协程,开始执行匿名函数中的代码,主协程继续向下执行,执行到runtime.Gosched( )时会暂停向下执行,直到其它协程执行完后,再回到该位置,主协程继续向下执行。

Goexit

        调用 runtime.Goexit() 将立即终止当前 goroutine 执⾏,调度器确保所有已注册 defer延迟调用被执行。

示例代码:

package main

import (
"fmt"
"runtime"
)

func main() {
    go func() {
        defer fmt.Println("A.defer")

        func() {
            defer fmt.Println("B.defer")
            runtime.Goexit() // 终止当前 goroutine, import "runtime"
            fmt.Println("B") // 不会执行
        }()

        fmt.Println("A") // 不会执行
    }() 	//不要忘记()

    //死循环,目的不让主goroutine结束
    for {
    }
}

程序运行结果:

 

GOMAXPROCS

        调用 runtime.GOMAXPROCS() 用来设置可以并行计算的CPU核数的最大值,并返回之前的值。

示例代码:

package main

import (
    "fmt"
)

func main() {
//n := runtime.GOMAXPROCS(1) 	// 第一次 测试
//打印结果:111111111111111111110000000000000000000011111...

n := runtime.GOMAXPROCS(2)         // 第二次 测试
//打印结果:010101010101010101011001100101011010010100110...
    fmt.Printf("n = %d\n", n)

    for {
        go fmt.Print(0)
        fmt.Print(1)
    }
}

        在第一次执行runtime.GOMAXPROCS(1) 时,最多同时只能有一个goroutine被执行。所以会打印很多1。过了一段时间后,GO调度器会将其置为休眠,并唤醒另一个goroutine,这时候就开始打印很多0了,在打印的时候,goroutine是被调度到操作系统线程上的。

        在第二次执行runtime.GOMAXPROCS(2) 时, 我们使用了两个CPU,所以两个goroutine可以一起被执行,以同样的频率交替打印0和1。

channel

        channel是Go语言中的一个核心类型,可以把它看成管道。并发核心单元通过它就可以发送或者接收数据进行通讯,这在一定程度上又进一步降低了编程的难度。

        channel是一个数据类型,主要用来解决协程的同步问题以及协程之间数据共享(数据传递)的问题。

        goroutine运行在相同的地址空间,因此访问共享内存必须做好同步。goroutine 奉行通过通信来共享内存,而不是共享内存来通信

        引⽤类型 channel可用于多个 goroutine 通讯。其内部实现了同步,确保并发安全。

Go并发编程详解_第9张图片

 

定义channel变量

        和map类似,channel也一个对应make创建的底层数据结构的引用

        当我们复制一个channel或用于函数参数传递时,我们只是拷贝了一个channel引用,因此调用者和被调用者将引用同一个channel对象。和其它的引用类型一样,channel的零值也是nil。

        定义一个channel时,也需要定义发送到channel的值的类型。channel可以使用内置的make()函数来创建:

        chan是创建channel所需使用的关键字。Type 代表指定channel收发数据的类型。

make(chan Type)  //等价于make(chan Type, 0)
make(chan Type, capacity)

        当我们复制一个channel或用于函数参数传递时,我们只是拷贝了一个channel引用,因此调用者和被调用者将引用同一个channel对象。和其它的引用类型一样,channel的零值也是nil。

        当 参数capacity= 0 时,channel 是无缓冲阻塞读写的;当capacity > 0 时,channel 有缓冲、是非阻塞的,直到写满 capacity个元素才阻塞写入。

        channel非常像生活中的管道,一边可以存放东西,另一边可以取出东西。channel通过操作符 <- 来接收和发送数据,发送和接收数据语法:

channel <- value      //发送value到channel
<-channel             //接收并将其丢弃
x := <-channel        //从channel中接收数据,并赋值给x
x, ok := <-channel    //功能同上,同时检查通道是否已关闭或者是否为空

        默认情况下,channel接收和发送数据都是阻塞的,除非另一端已经准备好,这样就使得goroutine同步变的更加的简单,而不需要显式的lock

示例代码:

package main

import (
    "fmt"
)

func main() {
    c := make(chan int)

    go func() {
        defer fmt.Println("子协程结束")

        fmt.Println("子协程正在运行……")

        c <- 666 //666发送到c
    }()

    num := <-c //从c中接收数据,并赋值给num

    fmt.Println("num = ", num)
    fmt.Println("main协程结束")
}

程序运行结果:

Go并发编程详解_第10张图片

 

无缓冲的channel

        无缓冲的通道(unbuffered channel)是指在接收前没有能力保存任何值的通道。

        这种类型的通道要求发送goroutine和接收goroutine同时准备好,才能完成发送和接收操作。否则,通道会导致先执行发送或接收操作的 goroutine 阻塞等待。

        这种对通道进行发送和接收的交互行为本身就是同步的。其中任意一个操作都无法离开另一个操作单独存在。

        阻塞:由于某种原因数据没有到达,当前协程(线程)持续处于等待状态,直到条件满足,才接触阻塞。

        同步:在两个或多个协程(线程)间,保持数据内容一致性的机制。

下图展示两个 goroutine 如何利用无缓冲的通道来共享一个值:

Go并发编程详解_第11张图片

 

  1. 在第 1 步,两个 goroutine 都到达通道,但哪个都没有开始执行发送或者接收。
  2. 在第 2 步,左侧的 goroutine 将它的手伸进了通道,这模拟了向通道发送数据的行为。这时,这个 goroutine 会在通道中被锁住,直到交换完成。
  3. 在第 3 步,右侧的 goroutine 将它的手放入通道,这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住,直到交换完成。
  4. 在第 4 步和第 5 步,进行交换,并最终,在第 6 步,两个 goroutine 都将它们的手从通道里拿出来,这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。

无缓冲的channel创建格式:

    make(chan Type)   //等价于make(chan Type, 0)

        如果没有指定缓冲区容量,那么该通道就是同步的,因此会阻塞到发送者准备好发送和接收者准备好接收。

示例代码:

package main

import (
    "fmt"
    "time"
)

func main() {
    c := make(chan int, 0) //创建无缓冲的通道 c 

    //内置函数 len 返回未被读取的缓冲元素数量,cap 返回缓冲区大小
    fmt.Printf("len(c)=%d, cap(c)=%d\n", len(c), cap(c))

    go func() {
        defer fmt.Println("子协程结束")

        for i := 0; i < 3; i++ {
            c <- i
            fmt.Printf("子协程正在运行[%d]: len(c)=%d, cap(c)=%d\n", i, len(c), cap(c))
        }
    }()

    time.Sleep(2 * time.Second) //延时2s

    for i := 0; i < 3; i++ {
        num := <-c //从c中接收数据,并赋值给num
        fmt.Println("num = ", num)
    }

    fmt.Println("main协程结束")
}

程序运行结果:

Go并发编程详解_第12张图片

 

有缓冲的channel

        有缓冲的通道(buffered channel)是一种在被接收前能存储一个或者多个数据值的通道。

        这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也不同。

        只有通道中没有要接收的值时,接收动作才会阻塞。

        只有通道没有可用缓冲区容纳被发送的值时,发送动作才会阻塞。

        这导致有缓冲的通道和无缓冲的通道之间的一个很大的不同:无缓冲的通道保证进行发送和接收的 goroutine 会在同一时间进行数据交换;有缓冲的通道没有这种保证。

示例图如下:

Go并发编程详解_第13张图片

 

  1. 在第 1 步,右侧的 goroutine 正在从通道接收一个值。
  2. 在第 2 步,右侧的这个 goroutine独立完成了接收值的动作,而左侧的 goroutine 正在发送一个新值到通道里。
  3. 在第 3 步,左侧的goroutine 还在向通道发送新值,而右侧的 goroutine 正在从通道接收另外一个值。这个步骤里的两个操作既不是同步的,也不会互相阻塞。
  4. 最后,在第 4 步,所有的发送和接收都完成,而通道里还有几个值,也有一些空间可以存更多的值。

有缓冲的channel创建格式:

make(chan Type, capacity)

        如果给定了一个缓冲区容量,通道就是异步的。只要缓冲区有未使用空间用于发送数据,或还包含可以接收的数据,那么其通信就会无阻塞地进行。

示例代码:

func main() {
    c := make(chan int, 3) //带缓冲的通道

    //内置函数 len 返回未被读取的缓冲元素数量, cap 返回缓冲区大小
    fmt.Printf("len(c)=%d, cap(c)=%d\n", len(c), cap(c))

    go func() {
        defer fmt.Println("子协程结束")

        for i := 0; i < 3; i++ {
            c <- i
            fmt.Printf("子协程正在运行[%d]: len(c)=%d, cap(c)=%d\n", i, len(c), cap(c))
        }
    }()

    time.Sleep(2 * time.Second) //延时2s
    for i := 0; i < 3; i++ {
        num := <-c //从c中接收数据,并赋值给num
        fmt.Println("num = ", num)
    }
    fmt.Println("main协程结束")
}

程序运行结果:

Go并发编程详解_第14张图片

 

关闭channel

        如果发送者知道,没有更多的值需要发送到channel的话,那么让接收者也能及时知道没有多余的值可接收将是有用的,因为接收者可以停止不必要的接收等待。这可以通过内置的close函数来关闭channel实现。

示例代码:

package main

import (
    "fmt"
)

func main() {
    c := make(chan int)

    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        //把 close(c) 注释掉,程序会一直阻塞在 if data, ok := <-c; ok 那一行
        close(c)
    }()

    for {
        //ok为true说明channel没有关闭,为false说明管道已经关闭
        if data, ok := <-c; ok {
            fmt.Println(data)
        } else {
            break
        }
    }

    fmt.Println("Finished")
}

程序运行结果:

Go并发编程详解_第15张图片

注意:

  1. channel不像文件一样需要经常去关闭,只有当你确实没有任何发送数据了,或者你想显式的结束range循环之类的,才去关闭channel;
  2. 关闭channel后,无法向channel 再发送数据(引发 panic 错误后导致接收立即返回零值)
  3. 关闭channel后,可以继续从channel接收数据;
  4. 对于nil channel,无论收发都会被阻塞。

可以使用 range 来迭代不断操作channel:

package main

import (
    "fmt"
)

func main() {
    c := make(chan int)

    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        //把 close(c) 注释掉,程序会一直阻塞在 for data := range c 那一行
        close(c)
    }()

    for data := range c {
        fmt.Println(data)
    }
    fmt.Println("Finished")
}

 单向channel及应用

默认情况下,通道channel是双向的,也就是,既可以往里面发送数据也可以同里面接收数据。

但是,我们经常见一个通道作为参数进行传递而值希望对方是单向使用的,要么只让它发送数据,要么只让它接收数据,这时候我们可以指定通道的方向。

Go并发编程详解_第16张图片

 单向channel变量的声明非常简单,如下:

var ch1 chan int       // ch1是一个正常的channel,是双向的
var ch2 chan<- float64 // ch2是单向channel,只用于写float64数据
var ch3 <-chan int     // ch3是单向channel,只用于读int数据
  1. chan<- 表示数据进入管道,要把数据写进管道,对于调用者就是输出。
  2. <-chan 表示数据从管道出来,对于调用者就是得到管道的数据,当然就是输入。

可以将 channel 隐式转换为单向队列,只收或只发,不能将单向 channel 转换为普通 channel:

   c := make(chan int, 3)
    var send chan<- int = c // send-only
    var recv <-chan int = c // receive-only
    send <- 1
    //<-send //invalid operation: <-send (receive from send-only type chan<- int)
    <-recv
    //recv <- 2 //invalid operation: recv <- 2 (send to receive-only type <-chan int)

    //不能将单向 channel 转换为普通 channel
    d1 := (chan int)(send) //cannot convert send (type chan<- int) to type chan int
    d2 := (chan int)(recv) //cannot convert recv (type <-chan int) to type chan int

示例代码:

//   chan<- //只写
func counter(out chan<- int) {
    defer close(out)
    for i := 0; i < 5; i++ {
        out <- i //如果对方不读 会阻塞
    }
}

//   <-chan //只读
func printer(in <-chan int) {
    for num := range in {
        fmt.Println(num)
    }
}

func main() {
    c := make(chan int) //   chan   //读写

    go counter(c) //生产者
    printer(c)    //消费者

    fmt.Println("done")
}

生产者消费者模型

        单向channel最典型的应用是“生产者消费者模型”

        所谓“生产者消费者模型”: 某个模块(函数等)负责产生数据,这些数据由另一个模块来负责处理(此处的模块是广义的,可以是类、函数、协程、线程、进程等)。产生数据的模块,就形象地称为生产者;而处理数据的模块,就称为消费者。

        单单抽象出生产者和消费者,还够不上是生产者/消费者模型。该模式还需要有一个缓冲区处于生产者和消费者之间,作为一个中介。生产者把数据放入缓冲区,而消费者从缓冲区取出数据。大概的结构如下图:

 

举一个寄信的例子来辅助理解一下,假设你要寄一封平信,大致过程如下:

        1. 把信写好——相当于生产者制造数据

        2. 把信放入邮筒——相当于生产者把数据放入缓冲区

        3. 邮递员把信从邮筒取出——相当于消费者把数据取出缓冲区

        4. 邮递员把信拿去邮局做相应的处理——相当于消费者处理数据

        那么,这个缓冲区有什么用呢?为什么不让生产者直接调用消费者的某个函数,直接把数据传递过去,而画蛇添足般的设置一个缓冲区呢?

缓冲区的好处大概如下:

1:解耦

        假设生产者和消费者分别是两个类。如果让生产者直接调用消费者的某个方法,那么生产者对于消费者就会产生依赖(也就是耦合)。将来如果消费者的代码发生变化,可能会直接影响到生产者。而如果两者都依赖于某个缓冲区,两者之间不直接依赖,耦合度也就相应降低了。

        接着上述的例子,如果不使用邮筒(缓冲区),须得把信直接交给邮递员。那你就必须要认识谁是邮递员。这就产生和你和邮递员之间的依赖(相当于生产者和消费者的强耦合)。万一哪天邮递员换人了,你还要重新认识下一个邮递员(相当于消费者变化导致修改生产者代码)。 而邮筒相对来说比较固定,你依赖它的成本比较低(相当于和缓冲区之间的弱耦合)。

2:处理并发

        生产者直接调用消费者的某个方法,还有另一个弊端。由于函数调用是同步的(或者叫阻塞的),在消费者的方法没有返回之前,生产者只好一直等在那边。万一消费者处理数据很慢,生产者只能无端浪费时间。

        使用了生产者/消费者模式之后,生产者和消费者可以是两个独立的并发主体。生产者把制造出来的数据往缓冲区一丢,就可以再去生产下一个数据。基本上不用依赖消费者的处理速度。

        其实最当初这个生产者消费者模式,主要就是用来处理并发问题的。

        从寄信的例子来看。如果没有邮筒,你得拿着信傻站在路口等邮递员过来收(相当于生产者阻塞);又或者邮递员得挨家挨户问,谁要寄信(相当于消费者轮询)。

3:缓存

        如果生产者制造数据的速度时快时慢,缓冲区的好处就体现出来了。当数据制造快的时候,消费者来不及处理,未处理的数据可以暂时存在缓冲区中。等生产者的制造速度慢下来,消费者再慢慢处理掉。

        假设邮递员一次只能带走1000封信。万一某次碰上情人节送贺卡,需要寄出去的信超过1000封,这时候邮筒这个缓冲区就派上用场了。邮递员把来不及带走的信暂存在邮筒中,等下次过来时再拿走。

示例代码:

package main

import "fmt"

// 此通道只能写,不能读。
func producer(out chan<- int)  {
   for i:= 0; i < 10; i++ {
      out <- i*i          		// 将 i*i 结果写入到只写channel
   }
   close(out)
}

// 此通道只能读,不能写
func consumer(in <-chan int)  {
   for num := range in {		// 从只读channel中获取数据
      fmt.Println("num =", num)
   }
}

func main()  {
   ch := make(chan int)		// 创建一个双向channel

   // 新建一个groutine, 模拟生产者,产生数据,写入 channel
   go producer(ch)     		// channel传参, 传递的是引用。

   // 主协程,模拟消费者,从channel读数据,打印到屏幕
   consumer(ch)      		// 与 producer 传递的是同一个 channel
}

        简单说明:首先创建一个双向的channel,然后开启一个新的goroutine,把双向通道作为参数传递到producer方法中,同时转成只写通道。子协程开始执行循环,向只写通道中添加数据,这就是生产者。主协程,直接调用consumer方法,该方法将双向通道转成只读通道,通过循环每次从通道中读取数据,这就是消费者。

注意:channel作为参数传递,是引用传递

模拟订单

        在实际的开发中,生产者消费者模式应用也非常的广泛,例如:在电商网站中,订单处理,就是非常典型的生产者消费者模式。

        当很多用户单击下订单按钮后,订单生产的数据全部放到缓冲区(队列)中,然后消费者将队列中的数据取出来发送者仓库管理等系统。

        通过生产者消费者模式,将订单系统与仓库管理系统隔离开,且用户可以随时下单(生产数据)。如果订单系统直接调用仓库系统,那么用户单击下订单按钮后,要等到仓库系统的结果返回。这样速度会很慢。

下面模拟一个下订单处理的过程。

package main

import "fmt"

type OrderInfo struct {     // 创建结构体类型OrderInfo,只有一个id 成员
   id int
}

func producer2(out chan <- OrderInfo)  {   	// 生成订单——生产者

   for i:=0; i<10; i++ {              	// 循环生成10份订单
      order := OrderInfo{id: i+1}
      out <- order                  		// 写入channel
   }
   close(out)				// 写完,关闭channel
}

func consumer2(in <- chan OrderInfo)  {       // 处理订单——消费者

   for order := range in {                   	// 从channel 取出订单
      fmt.Println("订单id为:", order.id)    // 模拟处理订单
   }
}

func main()  {
   ch := make(chan OrderInfo)  // 定义一个双向 channel, 指定数据类型为OrderInfo
   go producer2(ch)            // 建新协程,传只写channel
   consumer2(ch)               // 主协程,传只读channel
}

        OrderInfo为订单信息,这里为了简单只定义了一个订单编号属性,然后生产者模拟10个订单,消费者对产生的订单进行处理。

定时器

time.Timer

        Timer是一个定时器。代表未来的一个单一事件,你可以告诉timer你要等待多长时间。

type Timer struct {
   C <-chan Time
   r runtimeTimer
}

        它提供一个channel,在定时时间到达之前,没有数据写入timer.C会一直阻塞。直到定时时间到,向channel写入值,阻塞解除,可以从中读取数据。

示例代码:

package main

import (
	"fmt"
	"time"
)

func main() {
    //创建定时器,2秒后,定时器就会向自己的C字节发送一个time.Time类型的元素值
    timer1 := time.NewTimer(time.Second * 2)
    t1 := time.Now() //当前时间
    fmt.Printf("t1: %v\n", t1)

    t2 := <-timer1.C
    fmt.Printf("t2: %v\n", t2)

    //如果只是想单纯的等待的话,可以使用 time.Sleep 来实现
    timer2 := time.NewTimer(time.Second * 2)
    <-timer2.C
    fmt.Println("2s后")

    time.Sleep(time.Second * 2)
    fmt.Println("再一次2s后")

    <-time.After(time.Second * 2)
    fmt.Println("再再一次2s后")

    timer3 := time.NewTimer(time.Second)
    go func() {
        <-timer3.C
        fmt.Println("Timer 3 expired")
    }()

    stop := timer3.Stop() //停止定时器
    if stop {
        fmt.Println("Timer 3 stopped")
    }

    fmt.Println("before")
    timer4 := time.NewTimer(time.Second * 5) 	//原来设置3s
    timer4.Reset(time.Second * 1)            	//重新设置时间
    <-timer4.C
    fmt.Println("after")
}

定时器的常用操作:

1.实现延迟功能

         (1). <-time.After(2 * time.Second) //定时2s,阻塞2s,2s后产生一个事件,往channel写内容

                fmt.Println("时间到")

        (2). time.Sleep(2 * time.Second)

               fmt.Println("时间到")

        (3). ( 延时2s后打印一句话

                timer := time.NewTimer(2 * time.Second)

                <- timer.C

                fmt.Println("时间到")

2.定时器停止

timer := time.NewTimer(3 * time.Second)
    go func() {
        <-timer.C
        fmt.Println("子协程可以打印了,因为定时器的时间到")
    }()
    timer.Stop() //停止定时器

    for {
	}

3.定时器重置

timer := time.NewTimer(3 * time.Second)
	ok := timer.Reset(1 * time.Second) //重新设置为1s
	fmt.Println("ok = ", ok)
	<-timer.C
	fmt.Println("时间到")

time.Ticker

        Ticker是一个周期触发定时的计时器,它会按照一个时间间隔往channel发送系统当前时间,而channel的接收者可以以固定的时间间隔从channel中读取事件。

type Ticker struct {
   C <-chan Time 	// The channel on which the ticks are delivered.
   r runtimeTimer
}

示例代码:

package main

import (
	"fmt"
	"time"
)

func main() {
    //创建定时器,每隔1秒后,定时器就会给channel发送一个事件(当前时间)
    ticker := time.NewTicker(time.Second * 1)

    i := 0
    go func() {
        for { //循环
            <-ticker.C
            i++
            fmt.Println("i = ", i)

            if i == 5 {
                ticker.Stop() //停止定时器
            }
        }
    }() //别忘了()

    //死循环,特地不让main goroutine结束
    for {
    }
}

select

select作用

        Go里面提供了一个关键字select,通过select可以监听channel上的数据流动。

        select的用法与switch语言非常类似,由select开始一个新的选择块,每个选择条件由case语句来描述。

        与switch语句相比, select有比较多的限制,其中最大的一条限制就是每个case语句里必须是一个IO操作,大致的结构如下:

select {
    case <-chan1:
        // 如果chan1成功读到数据,则进行该case处理语句
    case chan2 <- 1:
        // 如果成功向chan2写入数据,则进行该case处理语句
    default:
        // 如果上面都没有成功,则进入default处理流程
    }

        在一个select语句中,Go语言会按顺序从头至尾评估每一个发送和接收的语句。

        如果其中的任意一语句可以继续执行(即没有被阻塞),那么就从那些可以执行的语句中任意选择一条来使用。

如果没有任意一条语句可以执行(即所有的通道都被阻塞),那么有两种可能的情况:

  1. 如果给出了default语句,那么就会执行default语句,同时程序的执行会从select语句后的语句中恢复。
  2. 如果没有default语句,那么select语句将被阻塞,直到至少有一个通信可以进行下去。

示例代码:

package main

import (
    "fmt"
)

func fibonacci(c, quit chan int) {
    x, y := 1, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)

    go func() {
        for i := 0; i < 6; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()

    fibonacci(c, quit)
}

运行结果如下:

Go并发编程详解_第17张图片

 

超时

        有时候会出现goroutine阻塞的情况,那么我们如何避免整个程序进入阻塞的情况呢?我们可以利用select来设置超时,通过如下的方式实现:

func main() {
    c := make(chan int)
    o := make(chan bool)
    go func() {
        for {
            select {
            case v := <-c:
                fmt.Println(v)
            case <-time.After(5 * time.Second):
                fmt.Println("timeout")
                o <- true
                break
            }
        }
    }()
    //c <- 666 // 注释掉,引发 timeout
    <-o
}

(扩展进阶) 锁和条件变量

        前面我们为了解决协程同步的问题我们使用了channel,但是GO也提供了传统的同步工具。

        它们都在GO的标准库代码包sync和sync/atomic中。

        下面我们看一下锁的应用。

        什么是锁呢?就是某个协程(线程)在访问某个资源时先锁住,防止其它协程的访问,等访问完毕解锁后其他协程再来加锁进行访问。这和我们生活中加锁使用公共资源相似,例如:公共卫生间。

死锁

        死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,

示例代码:

package main

import "fmt"

func main() {
ch := make(chan int)
ch <- 1   		// I'm blocked because there is no channel read yet. 
fmt.Println("send")
go func() {
    <-ch  		// I will never be called for the main routine is blocked!
    fmt.Println("received")
}()
fmt.Println("over")
}

互斥锁

        每个资源都对应于一个可称为 "互斥锁" 的标记,这个标记用来保证在任意时刻,只能有一个协程(线程)访问该资源。其它的协程只能等待。

        互斥锁是传统并发编程对共享资源进行访问控制的主要手段,它由标准库sync中的Mutex结构体类型表示。sync.Mutex类型只有两个公开的指针方法,Lock和Unlock。Lock锁定当前的共享资源,Unlock进行解锁。

        在使用互斥锁时,一定要注意:对资源操作完成后,一定要解锁,否则会出现流程执行异常,死锁等问题。通常借助defer。锁定后,立即使用defer语句保证互斥锁及时解锁。如下所示:

var mutex sync.Mutex		// 定义互斥锁变量 mutex

func write(){
   mutex.Lock( )
   defer mutex.Unlock( )
}

        我们可以使用互斥锁来解决前面提到的多任务编程的问题,如下所示:

package main

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

var mutex sync.Mutex

func printer(str string)  {
   mutex.Lock()               	// 添加互斥锁
   defer mutex.Unlock()         	// 使用结束时解锁

   for _, data := range str {    	// 迭代器
      fmt.Printf("%c", data)
      time.Sleep(time.Second)       // 放大协程竞争效果
   }
   fmt.Println()  			
}

func person1(s1 string)  {
   printer(s1)
}

func person2()  {
   printer("world")    		// 调函数时传参
}

func main()  {
   go person1("hello")   		// main 中传参
   go person2()
   for {
      ;
   }
}

        程序执行结果与多任务资源竞争时一致。最终由于添加了互斥锁,可以按序先输出hello再输出 world。但这里需要我们自行创建互斥锁,并在适当的位置对锁进行释放。

读写锁

        互斥锁的本质是当一个goroutine访问的时候,其他goroutine都不能访问。这样在资源同步,避免竞争的同时也降低了程序的并发性能。程序由原来的并行执行变成了串行执行。

        其实,当我们对一个不会变化的数据只做“读”操作的话,是不存在资源竞争的问题的。因为数据是不变的,不管怎么读取,多少goroutine同时读取,都是可以的。

        所以问题不是出在“读”上,主要是修改,也就是“写”。修改的数据要同步,这样其他goroutine才可以感知到。所以真正的互斥应该是读取和修改、修改和修改之间,读和读是没有互斥操作的必要的。

        因此,衍生出另外一种锁,叫做读写锁

        读写锁可以让多个读操作并发,同时读取,但是对于写操作是完全互斥的。也就是说,当一个goroutine进行写操作的时候,其他goroutine既不能进行读操作,也不能进行写操作。

        GO中的读写锁由结构体类型sync.RWMutex表示。此类型的方法集合中包含两对方法:

        一组是对写操作的锁定和解锁,简称“写锁定”和“写解锁”:

func (*RWMutex)Lock()

func (*RWMutex)Unlock()

        另一组表示对读操作的锁定和解锁,简称为“读锁定”与“读解锁”:

func (*RWMutex)RLock()

func (*RWMutex)RUlock()

读写锁基本示例:

package main

import (
   "sync"
   "fmt"
   "math/rand"
)

var count int           		// 全局变量count
var rwlock sync.RWMutex       	// 全局读写锁 rwlock

func read(n int)  {
   rwlock.RLock()
   fmt.Printf("读 goroutine %d 正在读取数据...\n", n)
   num := count
   fmt.Printf("读 goroutine %d 读取数据结束,读到 %d\n", n, num)
   defer rwlock.RUnlock()
}
func write(n int)  {
   rwlock.Lock()
   fmt.Printf("写 goroutine %d 正在写数据...\n", n)
   num := rand.Intn(1000)
   count = num
   fmt.Printf("写 goroutine %d 写数据结束,写入新值 %d\n", n, num)
   defer rwlock.Unlock()
}

func main()  {
   for i:=0; i<5; i++ {
      go read(i+1)
   }
   for i:=0; i<5; i++ {
      go write(i+1)
   }
   for {
      ;
   }
}

程序的执行结果:Go并发编程详解_第18张图片

 

        我们在read里使用读锁,也就是RLock和RUnlock,写锁的方法名和我们平时使用的一样,是Lock和Unlock。这样,我们就使用了读写锁,可以并发地读,但是同时只能有一个写,并且写的时候不能进行读操作。

        我们从结果可以看出,读取操作可以并行,例如2,3,1正在读取,但是同时只能有一个写,例如1正在写,只能等待1写完,这个过程中不允许进行其它的操作。

        处于读锁定状态,那么针对它的写锁定操作将永远不会成功,且相应的Goroutine也会被一直阻塞。因为它们是互斥的。

        总结:读写锁控制下的多个写操作之间都是互斥的,并且写操作与读操作之间也都是互斥的。但是,多个读操作之间不存在互斥关系。

        从互斥锁和读写锁的源码可以看出,它们是同源的。读写锁的内部用互斥锁来实现写锁定操作之间的互斥。可以把读写锁看作是互斥锁的一种扩展。

条件变量

        在讲解条件变量之前,先回顾一下前面我们所涉及的“生产者消费者模型”:

package main

import "fmt"

//只写,不读。
func producer(out chan<- int)  {
   for i:= 0; i < 10; i++ {
      out <- i*i          		
   }
   close(out)
}
//只读,不写
func consumer(in <-chan int)  {
   for num := range in {		
      fmt.Println("num = ", num)
   }
}
func main()  {
   ch := make(chan int)		// 创建一个双向channel
   go producer(ch)     		// 生产者,产生数据,写入 channel
   consumer(ch)      		// 消费者,从channel读数据,打印到屏幕
}

        这个案例中,虽然实现了生产者消费者的功能,但有一个问题。如果有多个消费者来消费数据,并且并不是简单的从channel中取出来进行打印,而是还要进行一些复杂的运算。在consumer( )方法中的实现是否有问题呢?

如下所示:

package main

import "fmt"
import "sync"
import "time"

var sum int 

func producer(out chan<- int) {
for i := 0; i < =100; i++ {
	out <-i
}
close(out);
}

// 此chanel 只能读,不能写
func consumer(in <-chan int) {
for num := range in {
	sum +=num
}
fmt.println(“sum = ”, sum) 
}

func main() {
    
    ch:= make(chan int)	// 创建一个双向通道
 go producer(ch)		// 协程1,生产者,生产数字,写入channel
 go consumer(ch)		// 协程2,消费者1
consumer(ch)		// 主协程,消费者。从channel读取内容打印
for  {
   ;
    }
}

        在上面的代码中,加了一个消费者,同时在consumer方法中,将数据取出来后,又进行了一组运算。这时可能会出现一个协程从管道中取出数据,参与加法运算,但是还没有算完另外一个协程又从管道中取出一个数据赋值给了num变量。所以这样累加计算,很有可能出现问题。当然,按照前面的知识,解决这个问题的方法很简单,就是通过加锁的方式来解决。增加生产者也是一样的道理。

        另外一个问题,如果消费者比生产者多,仓库中就会出现没有数据的情况。我们需要不断的通过循环来判断仓库队列中是否有数据,这样会造成cpu的浪费。反之,如果生产者比较多,仓库很容易满,满了就不能继续添加数据,也需要循环判断仓库满这一事件,同样也会造成CPU的浪费。

        我们希望当仓库满时,生产者停止生产,等待消费者消费;同理,如果仓库空了,我们希望消费者停下来等待生产者生产。为了达到这个目的,这里引入条件变量。(需要注意:如果仓库队列用channel,是不存在以上情况的,因为channel被填满后就阻塞了,或者channel中没有数据也会阻塞)。

        条件变量:条件变量的作用并不保证在同一时刻仅有一个协程(线程)访问某个共享的数据资源,而是在对应的共享数据的状态发生变化时,通知阻塞在某个条件上的协程(线程)。条件变量不是锁,在并发中不能达到同步的目的,因此条件变量总是与锁一块使用。

        例如,我们上面说的,如果仓库队列满了,我们可以使用条件变量让生产者对应的goroutine暂停(阻塞),但是当消费者消费了某个产品后,仓库就不再满了,应该唤醒(发送通知给)阻塞的生产者goroutine继续生产产品。

        GO标准库中的sys.Cond类型代表了条件变量。条件变量要与锁(互斥锁,或者读写锁)一起使用。成员变量L代表与条件变量搭配使用的锁。

type Cond struct {
   noCopy noCopy
   // L is held while observing or changing the condition
   L Locker
   notify  notifyList
   checker copyChecker
}

对应的有3个常用方法,Wait,Signal,Broadcast。

1. func (c *Cond) Wait()

        该函数的作用可归纳为如下三点:

        a. 阻塞等待条件变量满足       

        b. 释放已掌握的互斥锁相当于cond.L.Unlock()。 注意:两步为一个原子操作。

        c. 当被唤醒,Wait()函数返回时,解除阻塞并重新获取互斥锁。相当于cond.L.Lock()

2. func (c *Cond) Signal()

        单发通知,给一个正等待(阻塞)在该条件变量上的goroutine(线程)发送通知。

3. func (c *Cond) Broadcast()

        广播通知,给正在等待(阻塞)在该条件变量上的所有goroutine(线程)发送通知。

下面我们用条件变量来编写一个“生产者消费者模型”

示例代码:

package main
import "fmt"
import "sync"
import "math/rand"
import "time"

var cond sync.Cond             // 创建全局条件变量

// 生产者
func producer(out chan<- int, idx int) {
   for {
      cond.L.Lock()           	// 条件变量对应互斥锁加锁
      for len(out) == 3 {          	// 产品区满 等待消费者消费
         cond.Wait()             	// 挂起当前协程, 等待条件变量满足,被消费者唤醒
      }
      num := rand.Intn(1000) 	// 产生一个随机数
      out <- num             	// 写入到 channel 中 (生产)
      fmt.Printf("%dth 生产者,产生数据 %3d, 公共区剩余%d个数据\n", idx, num, len(out))
      cond.L.Unlock()             	// 生产结束,解锁互斥锁
      cond.Signal()           	// 唤醒 阻塞的 消费者
      time.Sleep(time.Second)       // 生产完休息一会,给其他协程执行机会
   }
}
//消费者
func consumer(in <-chan int, idx int) {
   for {
      cond.L.Lock()           	// 条件变量对应互斥锁加锁(与生产者是同一个)
      for len(in) == 0 {      	// 产品区为空 等待生产者生产
         cond.Wait()             	// 挂起当前协程, 等待条件变量满足,被生产者唤醒
      }
      num := <-in                	// 将 channel 中的数据读走 (消费)
      fmt.Printf("---- %dth 消费者, 消费数据 %3d,公共区剩余%d个数据\n", idx, num, len(in))
      cond.L.Unlock()             	// 消费结束,解锁互斥锁
      cond.Signal()           	// 唤醒 阻塞的 生产者
      time.Sleep(time.Millisecond * 500)    	//消费完 休息一会,给其他协程执行机会
   }
}
func main() {
   rand.Seed(time.Now().UnixNano())  // 设置随机数种子
   quit := make(chan bool)           // 创建用于结束通信的 channel

   product := make(chan int, 3)      // 产品区(公共区)使用channel 模拟
   cond.L = new(sync.Mutex)          // 创建互斥锁和条件变量

   for i := 0; i < 5; i++ {          // 5个消费者
      go producer(product, i+1)
   }
   for i := 0; i < 3; i++ {          // 3个生产者
      go consumer(product, i+1)
   }
   <-quit                         	// 主协程阻塞 不结束
}
  1. main函数中定义quit,其作用是让主协程阻塞。
  2. 定义product作为队列,生产者产生数据保存至队列中,最多存储3个数据,消费者从中取出数据模拟消费
  3. 条件变量要与锁一起使用,这里定义全局条件变量cond,它有一个属性:L Locker。是一个互斥锁。
  4. 开启5个消费者协程,开启3个生产者协程。
  5. producer生产者,在该方法中开启互斥锁,保证数据完整性。并且判断队列是否满,如果已满,调用wait()让该goroutine阻塞。当消费者取出数后执行cond.Signal(),会唤醒该goroutine,继续生产数据。
  6. consumer消费者,同样开启互斥锁,保证数据完整性。判断队列是否为空,如果为空,调用wait()使得当前goroutine阻塞。当生产者产生数据并添加到队列,执行cond.Signal() 唤醒该goroutine。

你可能感兴趣的:(Go语言,golang,后端,开发语言)