网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

第八章并发

2020-06-10 04:10:34 admin 855

## 1\. 并发和并行的区别

并行：多核cpu在同一时间片内并行处理多个任务。  
并发：如单核cpu在多个任务间进行时间片切换，并非同一时间片执行多个任务，只是上下文切换时间很短，看似多个任务并行。

多线程和多线程是并行的基本前提条件，单线程也可用协程做到并发。

在golang中是通过goroutine来实现并发的，goroutine并不能简单的归纳为协程，其运行时会创建多个线程来实现并发任务，且任务单元可被调度到其他线程并行执行。所以goroutine更像是多线程和协程的综合体，能最大限度提升执行效率，发挥多核处理能力。

### goroutine

关键字go并非执行并发操作，而是创建一个并发任务单元。新建任务被放置在系统队列中，等待调度器安排合适的系统线程去获取执行权。  
当前流程不会阻塞，不会等待该任务启动，且运行时也不保证并发任务的执行顺序。

每个任务单元除保存函数指针、调用参数外，还会分配执行所需的栈内存空间。相比系统默认MB级别的线程栈，goroutine自定义栈仅需2KB，所以才能创建成千上万的并发任务。自定义栈采取按需分配策略，在需要时仅需扩容，最大能到GB规模。

与defer一样，goroutine也会因延迟执行而立即计算并复制执行参数。

var c int
    func counter()int{
        c++
        return c
    }
    func main() {
        a:=100
        go func(x,y int) {
            time.Sleep(time.Second)
            fmt.Println("go:",x,y)
        }(a,counter())
        a+=100
        fmt.Println("main:",a,counter())
        time.Sleep(time.Second*3)
    }

输出：

main : 200 2
    go: 100 1

### wait

进程退出时不会等待并发任务结束，可用channel阻塞，然后发出退出信号。

func main() {
        exit:=make(chan interface{})  //创建通道。因为仅是通知，此处channel可为任何类型。
        go func() {
            time.Sleep(time.Second)
            fmt.Println("goroutine done")
            close(exit)                      //关闭通道，发出信号。
        }()
    
        fmt.Println("main...")
        <-exit                             //通道关闭则立即解除。
        fmt.Println("main exit")
    }

输出：

main...
    goroutine done
    main exit

除了关闭通道外，向通道内写入数据也可解除阻塞。channel的更多信息，后面再做详述。

如要等待多个任务结束，推荐使用sync.WaitGruop。通过设定计数器，让每个goroutine在退出前递减，直至归零时解除阻塞。

func main() {
        var wg sync.WaitGroup
    
        for i:=0;i<10;i++{
            wg.Add(1)         //累加计数
            go func(id int) {
                defer wg.Done()        //递减计数
                time.Sleep(time.Second)
                fmt.Println("goroutine",id,"done")
    
            }(i)
        }
    
        fmt.Println("main...")
        wg.Wait()                   //阻塞，直到计数归零
        fmt.Println("main exit")
    }

尽管WaitGroup.Add实现了原子操作，但建议在goroutine外累加计数器，以免Add尚未执行，Wait以及推出。

func main() {
        var wg sync.WaitGroup
        go func() {
            wg.Add(1)           //可以运行试一下，不是每次都能设置上
            defer wg.Done() //递减计数
            fmt.Println("goroutine", "done")
    
        }()
    
        fmt.Println("main...")
        wg.Wait() //阻塞，直到计数归零
        fmt.Println("main exit")
    }

可在多处用Wait阻塞，他们都能接收到通知。上栗就可在go func前加wg.Wait().

### GOMAXPROCS

运行时可能会创建很多线程，但任何时候仅有限的几个线程参与并发任务执行。该数量默认与CPU核数相等，可用runtime.GOMAXPROCS函数（或环境变量）修改。

* * *

如参数小于1，GOMAXPROCS仅返回当前设置值，不做任何调整。

* * *

import (
        "math"
        "fmt"
        "sync"
        "runtime"
    )
    
    //测试目标函数
    func count(){
        x:=0
        for i:=0;i<math.MaxUint32;i++{
            x+=i
        }
        fmt.Println(x)
    }
    
    //循环执行
    func test(n int){
        for i:=0;i<n;i++{
            count()
        }
    }
    
    //并发执行
    func test2(n int){
        var wg sync.WaitGroup
        wg.Add(n)
        for i:=0;i<n;i++{
            go func() {
                count()
                wg.Done()
            }()
        }
        wg.Wait()
    }
    
    func main() {
        n:=runtime.GOMAXPROCS(0)
        n1:=runtime.NumCPU()
        fmt.Println(n1)
        test(n)
    }

n :=runtime.GOMAXPROCS(0)
        n1:=runtime.NumCPU()

上述两个都可用来获取当前系统的cpu核数。

### Local Storage

与线程不同，goroutine任务无法设置优先级，无法获取编号，没有局部存储（TLS），甚至连返回值都会被抛弃。但除优先级外，其他功能都很容易实现。

func main() {
        var wg sync.WaitGroup
        var gs [5]struct{             //用于实现类似TLS功能
            id  int  //编号
            result  int //返回值
        }
        for i:=0;i<len(gs);i++{
            wg.Add(1)
            go func(id int) {   //使用参数避免参数闭包延迟求值
                defer wg.Done()
                gs[id].id = id
                gs[id].result=(id + 1) * 100
            }(i)
        }
        wg.Wait()
        fmt.Printf("%+v\n",gs)
    }

输出：

> [{id:0 result:100} {id:1 result:200} {id:2 result:300} {id:3 result:400}
> {id:4 result:500}]

**如使用map作为局部存储容器，建议做同步处理，因为运行时会对其做并发读写检查。

### Gosched

暂停，释放线程去执行其他任务。当前任务被放回队列，等待下次调度时恢复执行。

func main() {
        runtime.GOMAXPROCS(1)
        exit:=make(chan struct{})
    
        go func() {    //任务a
            defer close(exit)
    
            go func() {   //任务b，放在此处是为了确保a先执行。
                fmt.Println("b")
            }()
            for i:=0;i<4;i++{
                fmt.Println("a:", i)
                if i==1{
                    runtime.Gosched()
                }
            }
        }()
    
        <-exit
    }

输出：

a: 0
    a: 1
    b
    a: 2
    a: 3

该函数很少被使用，因为运行时会主动向长时间运行（10ms）的任务发出抢占调度。

### Goexit

Goexit立即终止当前任务，运行时确保所有已注册延迟调用被执行。该函数不会影响其他并发任务，不会引发panic，自然也就无法捕获。

func main() {
        exit:=make(chan struct{})
    
        go func() {
            defer close(exit)
            defer println("a")
            func(){
                defer func() {
                    println("b",recover() ==nil)   //执行recover返回nil
                }()
                func(){                                 //在多层调用中执行Goexit
                    println("c")
                    runtime.Goexit()                    //立即终止整个调用堆栈
                    println("c done.")            //不会执行
                }()
                println("b done.") //不会被执行
            }()
            println("a done.")  //不会执行
        }()
    
        <- exit
        println("main exit.")
    }

输出：

c
    b true
    a
    main exit.

如果在main.main里调用Goexit，它会等待其他任务结束，然后让进程直接崩溃。

* * *

无论身处哪一层，Goexit都能立即终止整个调用堆栈，这与return仅退出当前函数不同。 标准库函数os.Exit可终止进程，但不会执行延迟调用。

* * *

## 2\. 通道

Go并未实现严格的并发安全。  
允许全局变量、指针、引用类型这些非安全内存共享操作，就需要开发人员自行维护数据一致性和完整性。Go鼓励使用CSP通道，以通信代替内存共享，实现并发安全。  
通过消息来避免竟态的模型除了CSP，还有Actor。但两者区别较大。  
作为CSP核心，通道是显式的，要求操作双方必须知道数据类型和具体通道，并不关心另一端操作者身份和数量。可如果另一端未准备妥当，或消息未能及时处理时，会阻塞当前端。  
相比起来，Actor是透明的，它不在乎数据类型及通道，只要知道接收者信箱即可。默认就是异步方式，发送方对消息是否被接收和处理并不关心。

从底层实现上来说，通道只是一个队列。同步模式下，发送和接收双方配对，然后直接赋值数据给对方。如配对失败，则置入等待队列，直到另一方出现后才被唤醒。异步模式抢夺的则是数据缓冲槽。发送方要求有空槽可供写入，而接收方则要求有缓冲数据可读。需求不符时，同样加入等待队列，直到有另一方写入数据或腾出空槽后被唤醒。  
除传递消息外，通道还被用作时间通知。

func main() {
        done:=make(chan struct{})
        c:=make(chan string)
        go func() {
            s:=<-c
            fmt.Println(s)
            close(done)
        }()
    
        c<-"hello！"
        <-done   //阻塞，直到有数据或通道关闭
    }

同步模式必须有配对操作的goroutine出现，否则会一直阻塞。而异步模式在缓冲区未满或数据未读完前，不会阻塞。

func main() {
        c:=make(chan int,3)     //创建带三个缓冲槽的异步通道
        c<-1                    //缓冲区未满，不会阻塞
        c<-2
    
        println(<-c)
        println(<-c)
    }
    输出：
    1
    2

> 多数时候，异步通道有助于提升性能，减少排队阻塞。

缓冲区大小仅仅是内部属性，不属于类型组成部分。另外通道变量本身就是指针，可用相等操作符判断是否为同一对象或nil。

func main(){
        var a,b chan int = make(chan int,3),make(chan int)
        var c chan bool
        fmt.Println(a==b)
        fmt.Println(c==nil)
    
        fmt.Printf("%p,%d\n",a,unsafe.Sizeof(a))
    }
    输出：
    false
    true
    0xc04207a000,8

虽然可传递指针来避免数据复制，但须额外注意数据并发安全。  
内置函数cap和len返回缓冲区大小和当前已缓冲数量；而对于同步通道则都返回0，据此可判断通道是同步还是异步。

func main(){
        a,b:=make(chan int),make(chan int,3)
        b<-1
        b<-2
        println("a",len(a),cap(a))
        println("b",len(b),cap(b))
    }

输出：

a 0 0
    b 2 3

### 收发

除使用简单的发送和接收操作符外，还可用ok-idom或range模式处理数据。

func main() {
        done :=make(chan struct{})
        c:=make(chan int)
    
        go func() {
            defer close(done)
            for{
                x,ok:=<-c
                if !ok{               //据此判断通道是否关闭
                    return
                }
                fmt.Println(x)
            }
        }()
    
        c<-1
        c<-2
        c<-3
        close(c)
        <-done
    
    }

输出：1，2，3

对于循环接收数据，range模式更简洁一些。

[...]
        go func() {
            defer close(done)
            for x:=range c{       //循环获取消息，直到通道被关闭。
                println(x)
            }
        }()
    
    [...]

及时用close函数关闭通道引发结束通知，否则可能会导致死锁。  
通知可以是群体性的。也未必就是通知结束，可以是任何需要表达的事件。

一次性事件用close效率更好，没有多余开销。连续或多样性事件，可传递不同数据标志实现。还可使用sync.Cond实现单播或广播事件。  
对于closed或nil通道，发送或接收操作都有相应规则：

* 向已关闭通道发送数据，引发panic。
  * 从已关闭通道接收数据，返回已缓冲数据或零值。
  * 无论收发，nil通道都会阻塞。

func main(){
        c:=make(chan int,3)
        
        c<-10
        c<-20
        close(c)
    
        for i:=0;i<cap(c)+1;i++{
            x,ok:=<-c
            println(i,":",ok,x)
        }
    }

输出：

0 : true 10
    1 : true 20
    2 : false 0
    3 : false 0

重复关闭，或关闭nil通道都会引发panic错误。

### 单向

通道默认都是双向的，并不区分发送和接收端。但某些时候，我们可限制收发操作的方向来获得更严谨的操作逻辑。

尽管可用make创建单向通道，但那没有任何意义。通常使用类型转换来获取单向通道，并分别赋予操作双方。

func main() {
        var wg sync.WaitGroup
        wg.Add(2)
    
        c:=make(chan int)
        var send chan<- int =c
        var recv <-chan int =c
    
        go func() {
            defer wg.Done()
            for x:=range recv{
                println(x)
            }
        }()
    
        go func() {
            defer wg.Done()
            defer close(c)
            for i:=0;i<3;i++{
                send<-i
            }
        }()
    
        wg.Wait()
    
    }

不能在单向通道上做逆向操作。close也不能用于接收端。也无法将单向通道重新转换回去。

### 选择

如要同时处理多个通道，可选用Select语句。它会随机选择一个可用通道做收发操作。

func main() {
        var wg sync.WaitGroup
        wg.Add(2)
        a, b := make(chan int), make(chan int)
    
        go func() {             //接收端
            defer wg.Done()
            for {
                var (
                    name string
                    x    int
                    ok   bool
                )
                select {
                case x, ok = <-a:            //随机选择可用channel接收数据
                    name = "a"
                case x, ok = <-b:
                    name = "b"
                }
                if !ok {                     //如果任一通道关闭则终止接收。
                    return
                }
                println(name, x)  //输出接收的数据信息
    
            }
        }()
    
        go func() {         //发送端
            defer wg.Done()
            defer close(a)
            defer close(b)
    
            for i := 0; i < 10; i++ {
                select {
                case a <- i:
                case b <- i * 10:
    
                }
            }
    
        }()
    
        wg.Wait()
    }

输出：

b 0
    a 1
    a 2
    b 30
    a 4
    b 50
    a 6
    a 7
    a 8
    b 90

如果要等全部的通道消息处理结束，可将已完成的通道设置为nil，这样她就会被阻塞，而不再被Select选中。  
以下示例是两个独立的通道，逻辑是等两个通道都结束了收发才最终close，哪个先完成哪个阻塞住在那等待。

func main() {
        var wg sync.WaitGroup
        wg.Add(3)
        a, b := make(chan int), make(chan int)
    
        go func() { //接收端
            defer wg.Done()
            for {
                select {
                case x, ok := <-a:
                    if !ok {
                        a = nil
                        break
                    }
                    println("a",x)
                case x, ok := <-b:
                    if !ok {
                        b = nil
                        break
                    }
                    println("b", x)
                }
    
    
                if a == nil && b == nil {
                    return
                }
    
            }
        }()
    
        go func() {
            defer wg.Done()
            defer close(a)
    
            for i := 0; i < 10; i++ {
                a <- i
            }
    
        }()
    
        go func() {
            defer wg.Done()
            defer close(b)
    
            for i := 100; i < 105; i++ {
                b <- i
            }
    
        }()
    
        wg.Wait()
    }

输出：

a 0
    a 1
    b 100
    a 2
    a 3
    a 4
    b 101
    b 102
    b 103
    a 5
    b 104
    a 6
    a 7
    a 8
    a 9

即使是同一通道，也会随机选择case执行。

func main() {
        var wg sync.WaitGroup
        wg.Add(2)
        c := make(chan int)
    
        go func() { //接收端
            defer wg.Done()
            for {
                var x int
                var ok bool
                select {
                case x, ok = <-c:
                    println("a1",x)
                case x, ok = <-c:
                    println("a2", x)
                }
                if !ok {
                    return
                }
    
            }
        }()
    
        go func() {
            defer wg.Done()
            defer close(c)
    
            for i := 0; i < 10; i++ {
                select {
                case c<-i:
                case c<-i*10:
                }
            }
        }()
        wg.Wait()
    }

输出：

a1 0
    a1 1
    a2 2
    a2 3
    a1 4
    a1 50
    a1 60
    a1 7
    a2 80
    a2 90
    a2 0

当所有通道都不可用时，Select会执行default语句。如此可避开Select阻塞，但须注意处理外层循环，以免陷入空耗。

func main() {
        c:=make(chan int)
        done:=make(chan bool)
    
        go func() {
            defer close(done)
            for {
    
                select {
                case x,ok:=<-c:
                    if !ok{
                        return
                    }
                    fmt.Println("data:",x)
                default:                               //避免Select阻塞
    
                }
    
                fmt.Println(time.Now())
                time.Sleep(time.Second)
            }
        }()
        time.Sleep(5*time.Second)
        c<-100
        close(c)
        <-done
    }

输出：略

也可以用default处理一些默认逻辑。

func main() {
        done := make(chan struct{})
        data := []chan int{           //数据缓冲区
            make(chan int, 3),
        }
    
        go func() { //生产数据
            defer close(done)
            for i := 0; i < 10; i++ {
                select {
                case data[len(data)-1] <- i:   //生产数据
                default: //数据通道已满则新建chan
                    data = append(data, make(chan int, 3))
                }
            }
    
        }()
        <-done
    
        for x := 0; x < len(data); x++ {
            c := data[x]
            close(c)  //关闭通道后也能从中读取数据
            for i := range (c) {
                fmt.Println(i)
            }
        }
    
    }

输出：

0
    1
    2
    4
    5
    6
    8
    9

可以看到，channel缓存满了后的第一个数据会被丢弃，直接走default创建新的通道了。

### 模式

通常使用工厂方法将goroutine和通道绑定。

type receiver struct {
        wg   sync.WaitGroup
        data chan int
    }
    
    func newReceiver() *receiver {
        r := &receiver{
            data: make(chan int),
        }
        r.wg.Add(1)
        go func() {
            defer r.wg.Done()
            for x := range r.data { //接收消息，直到通道关闭
                println("recv:", x)
            }
        }()
        return r
    }
    
    func main() {
    
        r := newReceiver()
        r.data <- 1
        r.data <- 2
        close(r.data)  //关闭通道，发出结束通知
        r.wg.Wait()   //等待接收者处理结束
    
    }

输出：

recv: 1
    recv: 2

鉴于通道本身就是一个并发安全的队列，可用作ID generator、Pool等用途。

type pool chan []byte
    
    func newPool(cap int)pool{
        return make(chan []byte,cap)
    }
    
    func (p pool)get() []byte{
        var v []byte
        select {
        case v=<-p:                       //返回
        default:
            v=make([]byte,10)    //返回失败，新建
        }
        return v
    }
    
    func (p pool)put(b []byte){
        select {
        case p<-b:                //放回
        default:            //放回失败，新建
    
        }
    }

用通道实现信号量（semaphore）。

func main() {
        runtime.GOMAXPROCS(4)
        var wg sync.WaitGroup
    
        sem:=make(chan struct{}, 2)        //最多允许两个并发同时执行
        for i:=0;i<5;i++{
            wg.Add(1)
            go func(id int) {
                defer wg.Done()
                sem<- struct{}{}           // acquire: 获取信号
                defer func() {<-sem}()     //release: 释放信号
                time.Sleep(time.Second * 2)
                fmt.Println(id,time.Now())
            }(i)
        }
        wg.Wait()
    }

标准库time提供了timeout和tick channel实现。

package main
    
    import (
        "time"
        "fmt"
        "os"
    )
    
    func main() {
        go func() {
            for{
                select {
                case <-time.After(time.Second*5):
                    fmt.Println("timeout...")
                    os.Exit(0)
                }
            }
        }()
    
        go func() {
            tick:=time.Tick(time.Second)
            //for _=range tick{
            //  fmt.Println(time.Now(),"test")
            //}
            for {
                select {
                case <-tick:
                    fmt.Println(time.Now())
                }
            }
        }()
    
        <-(chan struct {})(nil)      //直接用nil channel阻塞进程
    }

捕获INT、TERM信号，顺便实现一个简易的atexit函数。

> atexit函数是一个特殊的函数，它是在正常程序退出时调用的函数，我们把他叫为登记函数（函数原型：int atexit (void
> (*)(void))）：  
>  ⼀个进程可以登记若⼲个（具体⾃⼰验证⼀下）个函数，这些函数由exit⾃动调⽤，这些函数被称为终⽌处理函数， atexit函数可以登记这些函数。
> exit调⽤终⽌处理函数的顺序和atexit登记的顺序相反（网上很多说造成顺序相反的原因是参数压栈造成的，参数的压栈是先进后出，和函数的栈帧相同），如果⼀个函数被多次登记，也会被多次调⽤。  
>  python中有专门的atexit模块，简介如下：  
>
> 从模块的名字也可以看出来，atexit模块主要的作用就是在程序即将结束之前执行的代码，atexit模块使用register函数用于注册程序退出时的回调函数，然后在回调函数中做一些资源清理的操作。  
>  注意：  
>  1，如果程序是非正常crash，或通过os._exit()退出，注册的回调函数将不会被调用。  
>  2，也可以通过sys.exitfunc来注册回调，但通过它只能注册一个回调，而且还不支持参数。  
>  3，建议使用atexit来注册回调函数。

import (
        "sync"
        "os"
        "os/signal"
        "syscall"
        "fmt"
    )
    
    //type atexits struct {
    //  sync.WaitGroup
    //  signal chan os.Signal
    //  funcs []func()
    //}
    var exits=&struct {
        sync.RWMutex
        signals chan os.Signal
        funcs []func()
    }{}
    
    func atexit(f func()){
        exits.Lock()
        defer exits.Unlock()
        exits.funcs=append(exits.funcs,f)
    }
    
    func waitExit(){
        if exits.signals==nil{
            exits.signals = make(chan os.Signal)
            signal.Notify(exits.signals,syscall.SIGINT,syscall.SIGTERM)
            fmt.Println("test")
        }
        exits.RLock()
        for _,f:=range exits.funcs{
            defer f()      //延迟调用函数采用FILO顺序执行。即便某些函数panic，延迟调用也能确保后续函数执行。
        }
        fmt.Println("after range exits.funcs")
        exits.RUnlock()
        fmt.Println("after exits.Runlock")
        <-exits.signals
    }
    
    func main() {
        atexit(func() {
            println("exit1...")
        })
        atexit(func() {
            println("exit2...")
        })
        fmt.Println("befor exit")
    
        waitExit()
    }

### 性能

将发往通道的数据打包，减少传输次数，可有效提升性能。从实现上来说，通道队列依旧使用锁同步机制，单次获取更多数据（批处理），可改善因频繁加锁造成的性能问题。

const (
        max     = 500000 //数据统计上限
        block   = 500    //数据块大小
        bufsize = 100    //缓冲区大小
    )
    
    func test() { //普通模式，每次传递一个整数
        done := make(chan struct{})
        c := make(chan int, bufsize)
    
        go func() {
            count := 0
            for x := range c {
                count += x
            }
            close(done)
        }()
    
        for i := 0; i < max; i++ {
            c <- i
        }
        close(c)
        <-done
    }
    
    func testBlock() { //块模式：每次将500个数字打包成块传输
        done := make(chan struct{})
        c:=make(chan [block]int,bufsize)
    
        go func() {
            count:=0
            for a:=range c{
                for _,x:=range a{  //a 是[block]int数组
                    count +=x
                }
            }
            fmt.Println(count)
            close(done)
        }()
    
        for i:=0;i<max;i+=block{
            var b [block]int       //使用数组对数据打包
            for n:=0; n<block;n++{
                b[n] = i+n
                if i+n == max -1{
                    break
                }
            }
    
            c <- b
        }
    
        close(c)
        <-done
    }

BenchmarkTest  
虽然单次消耗更多内存，但性能提升非常明显。如将数组改成切片会造成更多内存分配次数。

### 资源泄漏

通道可能会引发goroutine
leak，确切地说，是指goroutine处于发送或接受阻塞状态，但一直未被唤醒。垃圾回收器并不手机此类资源，导致它们会在等待队列里长久休眠，形成资源泄漏。

## 3\. 同步

通道并不是用来取代锁的，它们有各自不同的应用场景。通道倾向于解决逻辑层次的并发处理架构，而锁则用来保护局部范围内的数据安全。  
标准库sync提供了互斥和读写锁，另有原子操作等。mutex、rwmutex的使用并不复杂，只有几个地方需要注意。  
将Mutex作为匿名字段时，相关方法必须实现为pointer-receiver，否则会因复制导致锁机制失效。

type data struct {
        sync.Mutex
    }
    
    func (d data)test(s string){
        d.Lock()
        defer d.Unlock()
        for i:=0;i<5;i++{
            fmt.Println(s, i)
            time.Sleep(time.Second)
        }
    }
    func main() {
        var wg sync.WaitGroup
        var d data
        wg.Add(2)
    
        go func() {
            defer wg.Done()
            d.test("Read")
        }()
    
        go func() {
            defer wg.Done()
            d.test("write")
        }()
    
        wg.Wait()
    
    }

上述代码运行后会发现锁机制已失效，解决方案是将data 改为 _data.  
也可用嵌入_Mutex来避免复制问题，但那需要专门初始化。

应将Mutex锁粒度控制在最小范围内，及早释放。

Mutex不支持递归锁，即锁里面不允许有锁，否则即使在同一goroutine下也会导致死锁。  
在设计并发安全类型时，千万注意此类问题。

import "sync"
    
    type cache struct {
        sync.Mutex
        data []int
    }
    
    func (c *cache)count()int{
        c.Lock()
        n:=len(c.data)
        c.Unlock()
        return n
    }
    
    func (c *cache)get() int{
        c.Lock()
        defer c.Unlock()
        var d int
        if n:=c.count();n>0{    //锁中套锁
            d=c.data[0]
            c.data=c.data[1:]
        }
        return d
    }
    
    func main() {
    
        c:=cache{data:[]int{1,2,3,4}}
        c.get()
    }

输出：

fatal error: all goroutines are asleep - deadlock!

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

第八章并发

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

武云 2年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

第八章 并发

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

武云 2年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

第八章并发