闭包,sync使用细节

<h2>代码</h2>

先看代码如下：

<pre><code class="go">func main() { var a []int for i := 0; i < 100; i { go func() { a = append(a, i) }() } time.Sleep(2 * time.Second) fmt.Println(a) }</code></pre>

这段测试代码是想要一个元素为0到100的切片，但是这一小段代码隐藏了很多的问题。

<h2>闭包函数</h2>

先看这段代码的执行结果：

<pre><code>[10 12 13 13 13 13 21 24 25 28 28 28 28 28 28 29 29 29 36 38 39 39 40 41 41 41 41 41 41 45 45 45 45 46 47 48 49 50 51 52 61 61 61 61 61 61 61 61 61 61 73 73 74 74 75 76 76 77 77 77 77 77 77 77 77 77 83 85 85 88 88 89 91 92 93 93 93 93 93 93 93 93 100 100 100 100 100 100 100]</code></pre>

可以发现有很多元素是相同的，这就是这段代码的第一个错误：使用闭包函数的时候，代码中这种传递参数i的方法并非深copy，而是传递变量指针。解释一下产生这种情况的原因：<code>在并发执行时由于某一个协程修改了i的值，导致多个协程append的时候变量**i**的值发生变化，从而导致有多个重复的元素</code>。
将代码修改为：

<pre><code class="go">func main() { var a []int for i := 0; i < 100; i { go func(i int) { a = append(a, i) }(i) } time.Sleep(2 * time.Second) fmt.Println(a) } </code></pre>

执行结果为：

<pre><code>[5 4 8 7 2 12 15 13 14 24 22 23 25 18 21 17 20 28 29 31 30 32 33 34 35 36 37 38 39 41 40 42 44 50 45 48 49 55 51 52 53 54 46 47 57 56 58 59 60 65 61 62 63 64 68 66 67 70 69 72 74 71 73 75 76 80 77 78 79 86 81 82 83 85 89 87 88 84 90 91 92 95 93 94 97 96 98 99]</code></pre>

可以看到没有重复元素了，但是却缺少一些元素，这就引出了第二个问题。

<h2>多个协程的竞争问题</h2>

如上述代码，执行多次都会发现每次执行的结果都会少一些元素，其实真正的原因是<code>没有对于竞争的协程加互斥锁，导致资源的丢失</code>。
解释这个问题要对go的数组、切片、以及append机制有一些了解，参考：

<blockquote>Arrays, slices (and strings): The mechanics of 'append'</blockquote>

现在知道我们声明的切片不同于数组，在每次append的时候我们会伴随着内存copy以达到自动扩容目的，在A协程读出a的内存数据时，B协程完成了写入操作，此时A继续append并赋值就会导致，协程B的更新结果丢失。
假如我们将切片换成数组就不存在这个问题：

<pre><code> func main() { var a [100]int for i := 0; i < 100; i { go func(i int) { // a = append(a, i) a[i] = i }(i) } time.Sleep(2 * time.Second) fmt.Println(a) }</code></pre>

结果

<pre><code>[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99]</code></pre>

或者互斥锁，

<pre><code class="go">func main() { var a []int var mu sync.Mutex for i := 0; i < 100; i { go func(i int) { mu.Lock() a = append(a, i) mu.Unlock() }(i) } time.Sleep(2 * time.Second) fmt.Println(a) }</code></pre>

结果

<pre><code>[1 0 2 9 7 8 10 4 5 3 11 6 12 14 13 16 15 23 20 21 22 19 25 24 17 26 18 27 28 29 32 30 31 34 35 36 40 33 37 39 38 42 43 41 44 51 45 49 50 55 52 53 48 54 46 47 57 56 58 59 60 64 61 62 63 68 72 70 71 74 69 75 73 65 66 67 76 79 77 78 85 80 81 82 83 84 86 88 87 90 89 91 92 93 96 94 95 97 98 99]</code></pre> <h2>结论</h2> <ul><li>闭包使用注意变量传递是指针还是值，及注意闭包变量的两种传递方式。</li> <li>注意线程安全。</li> </ul><h2>结语</h2>

希望大家一起学习，一起交流，一起进步！

<blockquote>联系我
qq：820932773
gmail: jdqaffairs@gmail.com</blockquote> 到此这篇关于“闭包,sync使用细节”的文章就介绍到这了,更多文章或继续浏览下面的相关文章，希望大家以后多多支持JQ教程网！

您可能感兴趣的文章：
[译]如果对齐内存的写入是原子性的，为什么我们还需要sync/atomic包
闭包,sync使用细节
Golang 文件读写操作几种方法
外观模式的作用
使用mk-table-sync的总结
PHP中的闭包
Goroutine 的同步（第三部分）
golang goroutine 通知_深入golang之---goroutine并发控制与通信
如何在golang中关闭bufio.reader_golang 并发编程
PHP闭包的详细介绍（附代码）