Golang闭包问题及并发闭包问题

Golang闭包问题及并发闭包问题

参考原文链接：https://blog.youkuaiyun.com/qq_35976351/article/details/81986496

• ​ https://www.calhoun.io/what-is-a-closure/
  • ​ https://blog.cloudflare.com/a-go-gotcha-when-closures-and-goroutines-collide/

匿名函数

在引入闭包之前，我们需要先认识匿名函数。匿名函数与普通函数相同，但它没有名称 , 因此称为“匿名函数”。相反，匿名函数是动态创建的，就像变量一样。

我们可以创建一个具有函数类型的变量，然后就可以创建匿名函数并将其分配给变量。

	// 声明函数类型变量
	var fun func() 
	// 将匿名函数赋值给函数类型变量
	fun = func() {
		fmt.Println("匿名函数")	
	}
	// 调用函数
	fun()
  

匿名函数可以接受参数，返回数据，并执行普通函数可以执行的几乎任何其他操作.

闭包

闭包是一种特殊类型的匿名函数，它引用在函数本身之外声明的变量；是匿名函数与匿名函数所引用环境的组合

不仅仅是存储了一个函数的返回值，它同时存储了一个闭包的状态。

闭包可以不传入外部参数，仍然可以访问外部变量

这与常规函数引用全局变量的方式非常相似。你可能不会将这些变量作为参数直接传递到函数中，但函数在调用时可以访问它们。

package main

import "fmt"

func main() {
  n := 0
  add := func() int {
    n += 1
    return n
  }
  fmt.Println(add()) // 1
  fmt.Println(add()) // 2
}

注意：匿名函数可以访问变量 n，但在调用时从未将其作为参数传入。这就是使它成为关闭的原因！

闭包提供数据隔离

package main

import "fmt"

func main() {
  counter := newCounter()
  fmt.Println(counter()) // 1
  fmt.Println(counter()) // 2
  // fmt.Println(n)    报错  函数外无法访问闭包变量n ，只有闭包函数才可以持续访问修改变量n
}
// 闭包作为函数返回值
func newCounter() func() int {
  n := 0
  return func() int {
    n += 1
    return n
  }
}

在这个例子中，闭包引用变量，即使在函数完成运行之后也是如此。这意味着我们的闭包可以访问一个变量，该变量跟踪它被调用了多少次，但函数之外的其他代码无法访问该变量。这是闭包的众多好处之一 - 我们可以在函数调用之间持久化数据，同时将数据与其他代码隔离。

并发闭包

package main

import "fmt"

func main() {
	for i := 0; i < 10; i++ {
		fmt.Printf("%d ", i)
	}
}
//结果很容易看到是： 0 1 2 3 4 5 6 7 8 9

但如果，我们引入groutines并发运行，结果可能会出乎你的意料

	让代码并发执行，最大效率地利用 CPU
格式：runtime.GOMAXPROCS(逻辑CPU数量)
	这里的逻辑CPU数量可以有如下几种数值：
	<1：不修改任何数值。
	=1：单核心执行。
	>1：多核并发执行。
一般情况下，可以使用 runtime.NumCPU() 查询 CPU 数量，并使用 runtime.GOMAXPROCS() 函数进行设置，例如：
runtime.GOMAXPROCS(runtime.NumCPU())	

package main

import (
	"fmt"
    "runtime"
	"sync"
)

func main() {
	// 让代码并发执行，最大效率地利用 CPU
	runtime.GOMAXPROCS(runtime.NumCPU())
    
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			fmt.Printf("%d ", i)
			wg.Done()
		}()
	}
	
	wg.Wait()
}

如果你同时思考，那么你可能会预测输出将是数字 0 到 9 以某种随机顺序，具体取决于 10 个 goroutines 的精确运行时间。

但输出实际上是：

10 10 10 10 10 10 10 10 10 10

为什么

为什么？

因为每个 goroutines 的匿名函数 都在用每个 goroutines 生成的十个闭包之间共享单个变量 i。

goroutines 的输出将取决于它们何时开始运行的值。在上面的示例中，直到循环终止并具有值 10 之前，它们才真正开始运行。

这种现象的原因在于闭包共享外部的变量i，注意到，每次调用go就会启动一个goroutine，这需要一定时间；但是，启动的goroutine与for循环变量递增的groutine不是在同一个goroutine，可以把i认为处于主goroutine中。启动一个goroutine的速度远大于循环执行的速度，所以即使是第一个goroutine刚起启动时，外层的循环也执行到了最后一步了。由于所有的goroutine共享i，而且这个i会在最后一个使用它的goroutine结束后被销毁，所以最后的输出结果都是最后一步的i==10。

总的来说就是：

外层for循环执行，遇到内层go,就启动协程，然后循环+1，但是启动内层协程速度要慢于多个外层循环+1。

可能等到最后一个循环+1,第一个内层go协程才开始运行，加上闭包影响，每个协程并发执行，但是访问的i都是同一个i,都是10.

在外层循环中增加延时效果进行验证

func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())

	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			fmt.Println(i)
			wg.Done()
		}()
		time.Sleep(1 * time.Second)   // 每次外层for循环+1就时间延时1秒；
									// 每一步循环至少间隔一秒，而这一秒的时间足够启动一个goroutine了
									// 这样我们就可以输出正确结果了
	}
	wg.Wait()
}

解决方法

在实际的工程中，不可能进行延时，这样就没有并发的优势，一般采取下面两种方法：

1. 共享的环境变量作为函数参数传递:

   func main() {
   	runtime.GOMAXPROCS(runtime.NumCPU())
   
   	var wg sync.WaitGroup
   	for i := 0; i < 5; i++ {
   		wg.Add(1)
   		go func(i int) {
   			fmt.Println(i)
   			wg.Done()
   		}(i)
   	}
   	wg.Wait()
   }
   /*
   输出:
   4
   0
   3
   1
   2
   */
   
   

   输出结果不一定按照顺序，这取决于每个goroutine的实际情况，但是最后的结果是不变的。可以理解为，函数参数的传递是瞬时的，而且是在一个goroutine执行之前就完成，所以此时执行的闭包存储了当前i的状态。

   2.使用同名的变量保留当前的状态

func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())

	var wg sync.WaitGroup
	for i := 0; i < 5; i++ {
		wg.Add(1)
		i := i       // 注意这里的同名变量覆盖
		go func() {
			fmt.Println(i)
			wg.Done()
		}()
	}
	wg.Wait()
}
/*
输出结果：
4
2
0
3
1
*/

同名的变量i作为内部的局部变量，覆盖了原来循环中的i，此时闭包中的变量不再是共享外循环的i，而是都有各自的内部同名变量i，赋值过程发生于循环过程中，因此保证了独立。