Go 并发控制

Author：谁把年华错落成诗
发布时间：December 28, 2019
1219 views
No comments
1619 words
Categories： Golang

goroutine

Go语言的并发，就不得不提goroutine，其作为Go语言的一大特色，在日常开发中使用很多

Go goroutine理解

这里就不对goroutine进行描述了，直接进入正文

go并发控制方法主要有：

公共变量
channel
WaitGroup
context

公共变量

这是并发控制最简单的实现方式

声明一个公共变量
所有子goroutine共享这个变量，并不断轮询这个变量并检查是否有更新
在主进程中变更该公共变量
子goroutine检测到公共变量更新，执行相应的逻辑

package main

import (
   "fmt"
   "time"
)

func main() {
    // 公共变量
    state := true

    go func(){
        for state {
            println("goroutine A running")
            time.Sleep(1 * time.Second)
        }
        println("goroutine A exit")
    }()

    go func() {
        for state {
            println("goroutine B running")
            time.Sleep(1 * time.Second)
        }
        println("goroutine B exit")
    }()

    time.Sleep(2 * time.Second)
    state = false
    time.Sleep(2 * time.Second)

    fmt.Println("main func exit")
}

输出结果

goroutine B running
goroutine A running
goroutine A running
goroutine B running
goroutine B running
goroutine A running
goroutine A exit
goroutine B exit
main func exit

这种实现方式比较简单，但如果逻辑过于复杂，则变量不容易控制

channel

channel是goroutine之间主要的通讯方式，一般会和select搭配使用

Go channel 实现原理分析

channel在这里也不做过多描述，大致处理过程为：

声明一个可以判断结束的chan
在goroutine中，使用select判断chan接收到的值。如果接收到结束，就可以走结束逻辑。如果没有，那么就会执行预设的逻辑，或者default
主程序发送了结束的指令后
子goroutine接到结束指令，进行结束逻辑

package main

import (
   "fmt"
   "time"
)

func main() {
    // 初始化一个接收bool的channel
    c := make(chan bool)

    go func() {
        for {
            select {
            case <- c:
                fmt.Println("goroutine exit")
                return
            default: 
            fmt.Println("goroutine running.")
            }
            time.Sleep(100 * time.Millisecond)
        }
    }()

    time.Sleep(1 * time.Second)
    c <- false
    fmt.Println("main fun exit")
}

输出结果

goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine exit
main fun exit

这种方法比较优雅，但稍微复杂
如果要控制多个goroutine，或者goroutine嵌套，就比较麻烦

WaitGroup

Go语言提供同步包sync

sync包同步提供基本的同步原语，如互斥锁。除了Once和WaitGroup类型之外，大多数类型都是供低级库例程使用的。通过Channel和沟通可以更好地完成更高级别的同步。并且此包中的值在使用过后不要拷贝。

Sync.WaitGroup是一种实现并发控制方式，WaitGroup 对象内部有一个计数器，最初从0开始，它有三个方法：Add(), Done(), Wait() 用来控制计数器的数量。

Add(n) 把计数器设置为n
Done() 每次把计数器-1
wait() 会阻塞代码的运行，直到计数器地值减为0

package main

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

func main() {
    fmt.Println(time.Now().Format("2006-01-02 15:04:05"))

    //定义一个WaitGroup
    var synWait sync.WaitGroup

    //计数器设置为2
    synWait.Add(2)

    go func() {
        time.Sleep(1 * time.Second)
        fmt.Println("goroutine A finish |", time.Now().Format("2006-01-02 15:04:05"))
        
        //计数器减1
        synWait.Done()
    }()

    go func() {
        time.Sleep(3 * time.Second)
        fmt.Println("goroutine B finish |", time.Now().Format("2006-01-02 15:04:05"))
        
        //计数器减1
        synWait.Done()
    }()

    //会阻塞代码的运行，直到计数器地值减为0。
    synWait.Wait()

    fmt.Println("main fun exit |", time.Now().Format("2006-01-02 15:04:05"))
}

输出结果

2019-12-28 01:27:02
goroutine A finish | 2019-12-28 01:27:03
goroutine B finish | 2019-12-28 01:27:05
main fun exit | 2019-12-28 01:27:05

可以看出A在1秒后输出，B在3秒后输出

这种方法适合多个goroutine做同一个，或者差不多事情的时候
因为每个goroutine做的都是这件事情的一部分，只有全部的goroutine都完成，这件事情才算是完成，这是等待的方式。WaitGroup相对于channel并发控制方式比较轻巧

context

应用场景：在 Go http 包的 Server 中，每个Request都需要开启一个goroutine做一些事情，这些goroutine又可能会开启其他的goroutine
所以我们需要一种可以跟踪goroutine的方案，才可以达到控制他们的目的，这就是Go语言为我们提供的Context，称之为上下文

控制并发的实现方式：

context.Background():返回一个空的Context，这个空的Context一般用于整个Context树的根节点
context.WithCancel(context.Background())，创建一个可取消的子Context，然后当作参数传给goroutine使用，这样就可以使用这个子Context跟踪这个goroutine
在goroutine中，使用select调用<-ctx.Done()判断是否要结束，如果接收到值的话，就可以返回结束goroutine了。如果接收不到，就会继续进行监控
cancel()，取消函数（context.WithCancel()返回的第二个参数，名字和声明的名字一致）。作用是给goroutine发送结束指令

package main

import (
   "fmt"
   "time"
   "context"
)

func main() {
    //创建一个可取消子context,context.Background():返回一个空的Context，这个空的Context一般用于整个Context树的根节点
    ctx, cancel := context.WithCancel(context.Background())
    
    go func(ctx context.Context) {
        for {
            select {
            //使用select调用<-ctx.Done()判断是否要结束
            case <-ctx.Done():
                fmt.Println("goroutine exit")
                return
            default:
                fmt.Println("goroutine running.")
                time.Sleep(100 * time.Millisecond)
            }
        }
    }(ctx)

    time.Sleep(1 * time.Second)
    //取消context
    cancel()
    time.Sleep(1 * time.Second)

    fmt.Println("main fun exit")
}

输出结果

goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
main fun exit

如果想控制多个goroutine ，也很简单

package main

import (
   "fmt"
   "time"
   "context"
)

func main() {
    //创建一个可取消子context,context.Background():返回一个空的Context，这个空的Context一般用于整个Context树的根节点。
    ctxA, cancelA := context.WithCancel(context.Background())
    ctxB, cancelB := context.WithCancel(context.Background())

    go func(ctx context.Context) {
        for {
            select {
            //使用select调用<-ctx.Done()判断是否要结束
            case <- ctx.Done():
                fmt.Println("goroutine A exit")
                return
            default:
                fmt.Println("goroutine A running.")
                time.Sleep(200 * time.Millisecond)
            }
        }
    }(ctxA)

    go func(ctx context.Context) {
        for {
            select {
            //使用select调用<-ctx.Done()判断是否要结束
            case <- ctx.Done():
                fmt.Println("goroutine B exit")
                return
            default:
                fmt.Println("goroutine B running.")
                time.Sleep(200 * time.Millisecond)
            }
        }
    }(ctxA)

    go func(ctx context.Context) {
        for {
            select {
            //使用select调用<-ctx.Done()判断是否要结束
            case <- ctx.Done():
                fmt.Println("goroutine C exit")
                return
            default:
                fmt.Println("goroutine C running.")
                time.Sleep(200 * time.Millisecond)
            }
        }
    }(ctxB)

    time.Sleep(1 * time.Second)
    //取消context
    cancelA()
    cancelB()
    time.Sleep(1 * time.Second)
    
    fmt.Println("main fun exit")
}

输出结果：

goroutine A running.
goroutine C running.
goroutine B running.
goroutine A running.
goroutine C running.
goroutine B running.
goroutine A running.
goroutine C running.
goroutine B running.
goroutine A running.
goroutine C running.
goroutine B running.
goroutine A running.
goroutine C running.
goroutine B running.
goroutine A exit
goroutine C exit
goroutine B exit
main fun exit

至于context的具体用法，请参考深度解密Go语言之context

参考文档

Go goroutine理解
Go channel 实现原理分析
深度解密Go语言之context
Go 并发控制
GO语言并发编--sync包之WaitGroup的使用
Go Context的踩坑经历

版权属于：谁把年华错落成诗所有，转载请注明出处！
本文链接：https://blog.pomears.com/archives/52.html
如果博客部分链接出现404，请留言或者联系博主修复。

Last modification：August 11, 2020

If you think my article is useful to you, please feel free to appreciate

Go 并发控制

谁把年华错落成诗 • 2019 年 12 月 28 日

<img src="https://material.pomears.com/201912/goroutine.png?x-oss-process=style/yasuo" alt="goroutine" title="goroutine" style="">Go语言的并发，就不得不提goroutine，其作为Go语言的一大特色，在日常开发中使用很多<a class="no-external-link" href="https://segmentfault.com/a/1190000018150987" target="_blank">Go goroutine理解</a>这里就不对goroutine进行描述了，直接进入正文go并发控制方法主要有：<ol><li>公共变量</li><li>channel</li><li>WaitGroup</li><li>context</li></ol><h2>公共变量</h2>这是并发控制最简单的实现方式<ol><li>声明一个公共变量</li><li>所有子goroutine共享这个变量，并不断轮询这个变量并检查是否有更新</li><li>在主进程中变更该公共变量</li><li>子goroutine检测到公共变量更新，执行相应的逻辑</li></ol><pre><code>package main

import (
   &quot;fmt&quot;
   &quot;time&quot;
)

func main() {
    // 公共变量
    state := true

go func(){
        for state {
            println(&quot;goroutine A running&quot;)
            time.Sleep(1 * time.Second)
        }
        println(&quot;goroutine A exit&quot;)
    }()

go func() {
        for state {
            println(&quot;goroutine B running&quot;)
            time.Sleep(1 * time.Second)
        }
        println(&quot;goroutine B exit&quot;)
    }()

time.Sleep(2 * time.Second)
    state = false
    time.Sleep(2 * time.Second)

fmt.Println(&quot;main func exit&quot;)
}</code></pre>输出结果<pre><code>goroutine B running
goroutine A running
goroutine A running
goroutine B running
goroutine B running
goroutine A running
goroutine A exit
goroutine B exit
main func exit</code></pre>这种实现方式比较简单，但如果逻辑过于复杂，则变量不容易控制<h2>channel</h2><code>channel</code>是goroutine之间主要的通讯方式，一般会和<code>select</code>搭配使用<a class="no-external-link" href="https://github.com/guyan0319/golang_development_notes/blob/master/zh/9.9.md" target="_blank">Go channel 实现原理分析</a>channel在这里也不做过多描述，大致处理过程为：<ol><li>声明一个可以判断结束的chan</li><li>在goroutine中，使用select判断chan接收到的值。如果接收到结束，就可以走结束逻辑。如果没有，那么就会执行预设的逻辑，或者default</li><li>主程序发送了结束的指令后</li><li>子goroutine接到结束指令，进行结束逻辑</li></ol><pre><code>package main

import (
   &quot;fmt&quot;
   &quot;time&quot;
)

func main() {
    // 初始化一个接收bool的channel
    c := make(chan bool)

go func() {
        for {
            select {
            case &lt;- c:
                fmt.Println(&quot;goroutine exit&quot;)
                return
            default: 
            fmt.Println(&quot;goroutine running.&quot;)
            }
            time.Sleep(100 * time.Millisecond)
        }
    }()

time.Sleep(1 * time.Second)
 c &lt;- false
 fmt.Println(&quot;main fun exit&quot;)
}</code></pre>输出结果<pre><code>goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine exit
main fun exit</code></pre>这种方法比较优雅，但稍微复杂 如果要控制多个goroutine，或者goroutine嵌套，就比较麻烦<h2>WaitGroup</h2>Go语言提供同步包sync<code>sync</code>包同步提供基本的同步原语，如互斥锁。除了<code>Once</code>和<code>WaitGroup</code>类型之外，大多数类型都是供低级库例程使用的。通过Channel和沟通可以更好地完成更高级别的同步。并且此包中的值在使用过后不要拷贝。<code>Sync.WaitGroup</code>是一种实现并发控制方式，<code>WaitGroup</code> 对象内部有一个计数器，最初从0开始，它有三个方法：<code>Add()</code>, <code>Done()</code>, <code>Wait()</code> 用来控制计数器的数量。<ul><li>Add(n) 把计数器设置为n</li><li>Done() 每次把计数器-1</li><li>wait() 会阻塞代码的运行，直到计数器地值减为0</li></ul><pre><code>package main

import (
   &quot;fmt&quot;
   &quot;sync&quot;
   &quot;time&quot;
)

func main() {
    fmt.Println(time.Now().Format(&quot;2006-01-02 15:04:05&quot;))

//定义一个WaitGroup
    var synWait sync.WaitGroup

//计数器设置为2
    synWait.Add(2)

go func() {
        time.Sleep(1 * time.Second)
        fmt.Println(&quot;goroutine A finish |&quot;, time.Now().Format(&quot;2006-01-02 15:04:05&quot;))
        
        //计数器减1
        synWait.Done()
    }()

go func() {
        time.Sleep(3 * time.Second)
        fmt.Println(&quot;goroutine B finish |&quot;, time.Now().Format(&quot;2006-01-02 15:04:05&quot;))
        
        //计数器减1
        synWait.Done()
    }()

//会阻塞代码的运行，直到计数器地值减为0。
    synWait.Wait()

fmt.Println(&quot;main fun exit |&quot;, time.Now().Format(&quot;2006-01-02 15:04:05&quot;))
}</code></pre>输出结果<pre><code>2019-12-28 01:27:02
goroutine A finish | 2019-12-28 01:27:03
goroutine B finish | 2019-12-28 01:27:05
main fun exit | 2019-12-28 01:27:05</code></pre>可以看出A在1秒后输出，B在3秒后输出这种方法适合多个goroutine做同一个，或者差不多事情的时候 因为每个goroutine做的都是这件事情的一部分，只有全部的goroutine都完成，这件事情才算是完成，这是等待的方式。<code>WaitGroup</code>相对于<code>channel</code>并发控制方式比较轻巧<h2>context</h2>应用场景：在 Go http 包的 Server 中，每个Request都需要开启一个goroutine做一些事情，这些goroutine又可能会开启其他的goroutine 所以我们需要一种可以跟踪goroutine的方案，才可以达到控制他们的目的，这就是Go语言为我们提供的<code>Context</code>，称之为上下文控制并发的实现方式：<ol><li>context.Background():返回一个空的Context，这个空的Context一般用于整个Context树的根节点</li><li>context.WithCancel(context.Background())，创建一个可取消的子Context，然后当作参数传给goroutine使用，这样就可以使用这个子Context跟踪这个goroutine</li><li>在goroutine中，使用select调用&lt;-ctx.Done()判断是否要结束，如果接收到值的话，就可以返回结束goroutine了。如果接收不到，就会继续进行监控</li><li>cancel()，取消函数（context.WithCancel()返回的第二个参数，名字和声明的名字一致）。作用是给goroutine发送结束指令</li></ol><pre><code>package main

import (
   &quot;fmt&quot;
   &quot;time&quot;
   &quot;context&quot;
)

func main() {
    //创建一个可取消子context,context.Background():返回一个空的Context，这个空的Context一般用于整个Context树的根节点
    ctx, cancel := context.WithCancel(context.Background())
    
    go func(ctx context.Context) {
        for {
            select {
            //使用select调用&lt;-ctx.Done()判断是否要结束
            case &lt;-ctx.Done():
                fmt.Println(&quot;goroutine exit&quot;)
                return
            default:
                fmt.Println(&quot;goroutine running.&quot;)
                time.Sleep(100 * time.Millisecond)
            }
        }
    }(ctx)

time.Sleep(1 * time.Second)
    //取消context
    cancel()
    time.Sleep(1 * time.Second)

fmt.Println(&quot;main fun exit&quot;)
}</code></pre>输出结果<pre><code>goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
goroutine running.
main fun exit</code></pre>如果想控制多个goroutine ，也很简单<pre><code>package main

import (
   &quot;fmt&quot;
   &quot;time&quot;
   &quot;context&quot;
)

func main() {
    //创建一个可取消子context,context.Background():返回一个空的Context，这个空的Context一般用于整个Context树的根节点。
    ctxA, cancelA := context.WithCancel(context.Background())
    ctxB, cancelB := context.WithCancel(context.Background())

go func(ctx context.Context) {
        for {
            select {
            //使用select调用&lt;-ctx.Done()判断是否要结束
            case &lt;- ctx.Done():
                fmt.Println(&quot;goroutine A exit&quot;)
                return
            default:
                fmt.Println(&quot;goroutine A running.&quot;)
                time.Sleep(200 * time.Millisecond)
            }
        }
    }(ctxA)

go func(ctx context.Context) {
        for {
            select {
            //使用select调用&lt;-ctx.Done()判断是否要结束
            case &lt;- ctx.Done():
                fmt.Println(&quot;goroutine B exit&quot;)
                return
            default:
                fmt.Println(&quot;goroutine B running.&quot;)
                time.Sleep(200 * time.Millisecond)
            }
        }
    }(ctxA)

go func(ctx context.Context) {
        for {
            select {
            //使用select调用&lt;-ctx.Done()判断是否要结束
            case &lt;- ctx.Done():
                fmt.Println(&quot;goroutine C exit&quot;)
                return
            default:
                fmt.Println(&quot;goroutine C running.&quot;)
                time.Sleep(200 * time.Millisecond)
            }
        }
    }(ctxB)

time.Sleep(1 * time.Second)
 //取消context
 cancelA()
 cancelB()
 time.Sleep(1 * time.Second)
 
 fmt.Println(&quot;main fun exit&quot;)
}</code></pre>输出结果：<pre><code>goroutine A running.
goroutine C running.
goroutine B running.
goroutine A running.
goroutine C running.
goroutine B running.
goroutine A running.
goroutine C running.
goroutine B running.
goroutine A running.
goroutine C running.
goroutine B running.
goroutine A running.
goroutine C running.
goroutine B running.
goroutine A exit
goroutine C exit
goroutine B exit
main fun exit</code></pre>至于context的具体用法，请参考<a class="no-external-link" href="https://godoc.org/go.mongodb.org/mongo-driver/bson" target="_blank">深度解密Go语言之context</a><h2>参考文档</h2><a class="no-external-link" href="https://segmentfault.com/a/1190000018150987" target="_blank">Go goroutine理解</a> <a class="no-external-link" href="https://github.com/guyan0319/golang_development_notes/blob/master/zh/9.9.md" target="_blank">Go channel 实现原理分析</a> <a class="no-external-link" href="https://godoc.org/go.mongodb.org/mongo-driver/bson" target="_blank">深度解密Go语言之context</a> <a class="no-external-link" href="https://segmentfault.com/a/1190000019229973" target="_blank">Go 并发控制</a> <a class="no-external-link" href="https://blog.csdn.net/zg_hover/article/details/81194445" target="_blank">GO语言并发编--sync包之WaitGroup的使用</a> <a class="no-external-link" href="https://studygolang.com/articles/12566" target="_blank">Go Context的踩坑经历</a><hr class="content-copyright" style="margin-top:50px" /><blockquote class="content-copyright" style="font-style:normal">版权属于：<a class="no-external-link" href="https://blog.xiec.live" target="_blank">谁把年华错落成诗</a> 所有，转载请注明出处！本文链接：<a class="content-copyright" href="https://blog.pomears.com/archives/52.html">https://blog.pomears.com/archives/52.html</a>如果博客部分链接出现404，请留言或者联系博主修复。</blockquote>

Go 并发控制

公共变量

channel

WaitGroup

context

参考文档

Leave a Comment Cancel reply
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

使用typecho搭建博客

Go连接mongodb库并增删改查

解决typecho上传附件失败的问题

3种网页鼠标点击特效

React中获取input组件输入的的值

关于yarn安装node-sass失败的问题

node连接mysql

React组件的生命周期

React中获取input组件输入的的值

Go使用WaitGroup与channel控制goroutine数量

Go 并发控制

公共变量

channel

WaitGroup

context

参考文档

Leave a Comment Cancel reply 使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

Go 并发控制

Leave a Comment Cancel reply
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款