深入理解Golang - 闭包

た入场券 2023-01-13 09:58 213阅读 0赞

[文章链接 - golang内核系列–深入理解函数闭包 - buptbill220的文章 - 知乎][- golang_ - buptbill220_ -]

–  
问题  
闭包 是由函数及其相关引用环境组合而成的实体(即：闭包=函数+引用环境)。  
“官方”的解释是：所谓“闭包”，指的是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。  
比如下面“斐波那契数列”闭包：

func fib() func() int { 
    	a, b := 0, 1
    	return func() int { 
    		a, b = b, a+b
    		return a
    	}
    }
    
    调用如下
    f00 := fib()
    fmt.Println(f00(), f00(), f00(), f00(), f00())
    输出结果是：1 1 2 3 5

golang里是如何做到这种闭包管理的呢？

闭包实现  
我们先对闭包分3种场景：

**闭包里没有引用环境（变量生命周期很短，调用完即释放）  
闭包里引用全局变量（变量生命周期就是全局变量生命周期）  
闭包里引用局部变量（变量生命周期长，调用完不释放，下次调用会继续引用）**

分别对3种场景以以下代码进行分析：

var y int
    
    // 第一种场景
    func fib01() func() int { 
    	return func() int { 
    		a, b := 0, 1
    		a, b = b, a+b
    		return a
    	}
    }
    
    // 第二种场景
    func fib00() func() int { 
    	return func() int { 
    		y++
    		return y
    	}
    }
    
    // 第三种场景
    func fib3(x int) func() int { 
    	a, b := 0, 1
    	return func() int { 
    		a, b = b, a+b
    		x++
    		return a+x
    	}
    }

保存上述文件为closure.go，然后在用汇编工具生成汇编代码。汇编参考golang内核系列–深入理解plan9汇编&实践  
git：git@github.com:buptbill220/gotls.git

使用如下命名生成汇编：

go tool compile -S closure.go > closure.S  
我们打开closure.S找到对应的函数闭包位置

**第一种场景fib01**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70]  
然后找到 “”.fib01.func1  
![在这里插入图片描述][20210417214232274.png]  
闭包在全局区定义到代码段

"".fib01.func1·f SRODATA dupok size=8

我们可以看到：这种情况就是一种普通的函数，直接返回函数地址然后调用  
![在这里插入图片描述][20210417214256976.png]  
为了帮助理解这个实现，我们手动使用汇编根据一个函数地址调用函数

TEXT ·CallTest(SB),NOSPLIT,$0-8
        MOVQ arg+0(FP), AX
        CALL AX
        RET
    
    func call_test() { 
    	fmt.Printf("call test")
    }
    
    func CallTest(uintptr)
    
    x := call_test
    CallTest(**(*(*uintptr))(unsafe.Pointer(&x)))
    
    结果输出：call test

**第二种场景fib00**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 1]  
然后找到 “”.fib00.func1  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 2]

y的位置

“”.y SNOPTRBSS size=8  
我们可以看到，第二种场景也是返回函数闭包的地址，只是闭包内部访问全局变量，并不做额外的工作。可以和场景1归纳为一类

--------------------

**第三种场景fib3**  
由于汇编较多，拆为2部分  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 4]  
然后找到 “”.fib3.func1  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 5]  
通过上述分析，我们可以得知，所有引用局部变量，Golang在生成汇编是帮我们在堆上创建该变量的一个拷贝，并把该变量地址和函数闭包组成一个结构体，并把该结构体传出来作为返回值。  
结构体形式如下：

type FF struct { 
    	F unitptr
    	B *int
    	A *int
    	X *int // 如果X是string/[]int，那么这里应该为*string，*[]int
    }

这个结构有个特点：结构里变量顺序和函数里引用顺序刚好相反。这是因为Golang为了保持物理地址顺序一致性的结果。

*  栈的物理空间增长顺序是从大到小，栈里看到地址顺序是x>a>b
 *  而我们引用的是堆上物理空间增长顺序是从小到大，为了保持和栈上物理地址顺序一致，生成的结构顺序就是b、a、x  
    为了帮助理解这种实现，我们手动把函数闭包转换成结构并输出：

type FF struct { 
    	F unitptr
    	b *int
    	a *int
    	x *int
    }
    f := fib3(0)
    ptr := *(**FF)(unsafe.Pointer(&f))
    fmt.Printf("ptr %v, %d, %d, %d\n", ptr, *ptr.a, *ptr.b, *ptr.x)
    fmt.Println(f(), f(), f(), f(), f())
    fmt.Printf("ptr %v, %d, %d, %d\n", ptr, *ptr.a, *ptr.b, *ptr.x)
    
    自己手动调试看看

这里还有另一个特点：函数闭包内部本身是通过寄存器来访问引用环境的变量，在闭包调用前会把该结构地址提前放置寄存器（这里放到DX）  
我们可以看看闭包调用前的代码：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 6]  
**总结**

golang的函数闭包实现主要分为2中场景：

**闭包里没有引用环境&获取引用全局变量。这种场景下，其实现就是普通的函数，按照普通的函数调用方式执行闭包调用。  
闭包里引用局部变量。这种场景下，才是真正的闭包（函数+引用环境），并且以一个struct\{FuncAddr, LocalAddr3, LocalAddr2, LocalAddr1\}结构存储该闭包，等到调用闭包时，会把该结构地址提前放置一个寄存器，闭包内部通过该寄存器访问引用环境的变量**

[- golang_ - buptbill220_ -]: https://zhuanlan.zhihu.com/p/56750616
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70]: /images/20221022/642f726644014b40926273920db0f34c.png
[20210417214232274.png]: /images/20221022/a022043662a646b3b430ba6d84522345.png
[20210417214256976.png]: /images/20221022/ab18f3db18014bb999f99826297629d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 1]: /images/20221022/c8f2d5ec9e2c4d17bbf1242ad39aa2f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 2]: /images/20221022/9402c2ebba8b4058b396da65f32e38ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 3]: /images/20221022/ff69226ba7474fa69138a0ce42588e3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 4]: /images/20221022/a71e6a3bb553458aa1cb855a5626250f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 5]: /images/20221022/c259767c26924ab086ffb53439dc4758.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 6]: /images/20221022/1ec40ec45945472bbd83b62f2954f52f.png