lua闭包Upvalue

闭包

lua任何函数都是闭包,闭包至少带1个upValue;

CClosure是使用Lua提供的lua_pushcclosure这个C-Api加入到虚拟栈中的C函数,它是对LClosure的一种C模拟

如string.gmatch就是cclosure

定义:

#define ClosureHeader \
	CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \
	struct Table *env

typedef struct CClosure {
  ClosureHeader;
  lua_CFunction f;
  TValue upvalue[1];
} CClosure;


typedef struct LClosure {
  ClosureHeader;
  struct Proto *p;
  UpVal *upvals[1];
} LClosure;


typedef union Closure {
  CClosure c;
  LClosure l;
} Closure;

上值

local a = 1
local b = 2
function xxx()
    local c = 3
    local d = 4
    print(a + b)
    function yyy()
        print(c + d)
    end
end

在这里插入图片描述

我们可以看到,每个lua函数,都有一个upvalue列表,并且他们首个upvalue,都是一个名为_ENV的upvalue,内层lua函数的_ENV指向外层lua函数的_ENV,而最外层的top-level函数,则将值指向了全局表_G。为什么lua要用这种组织方式?将_ENV作为每个lua函数的第0个upvalue呢?我认为,这是为了效率,同时也能是的逻辑更为清晰,lua函数去查找一个变量的方式,如下所示:

lua函数查找一个变量v,首先会在自己的local变量中查找,如果找到就直接获取它的值,找不到则进入下一步
查找upvalue列表,有没有一个名为v的upvalue,有则获取它的值,没有则进入下一步
到_ENV里去查找一个名为v的值

上值的确定(编译期)

用来表示upvalue的有两个数据结构,一个是编译时期,存储upvalue信息的Upvaldesc(这个结构并不存储upvalue的实际值,只是用来标记upvalue的位置信息),还有一个是在运行期,实际存储upvalue值的UpVal结构。它们的结构定义如下所示:

typedef struct upvaldesc {
  lu_byte in_stack;
  lu_byte idx;
  TString* name;
} upvaldesc;

typedef struct  UpVal {
  CommonHeader;
  TValue *v;  /* points to stack or to its own value */
  union {
	// 当这个upval被close时,保存upval的值,后面可能还会被引用到
    TValue value;  /* the value (when closed) */
    // 当这个upval还在open状态时,以下链表串连在openupval链表中
    struct {  /* double linked list (when open) */
      struct UpVal *prev;
      struct UpVal *next;
    } l;
  } u;
} UpVal;

举例:

local a = 1
local b = 2
function xxx()
    local c = 3
    print(a)
    function yyy()
        print(a+b+c)
    end
end

编译期确定upvalue,最终的结构如下:
在这里插入图片描述
LClosure实际是运行时才会实例化的,这里为了展示方便;
分成3个level, top level, level2, level3;
top level: Upvaldesc列表只有1个,指代_ENV
level2: Upvaldesc列表有3个,第一个是_ENV, 是上一级的上值列表的第一个(所以in_stack=0,idx=0); 第二个是变量a, 是上一级的局部变量在栈上第一个(所以in_stack=1,idx=0);第三个是变量b, 是上一级的局部变量在栈上第二个(所以in_stack=1,idx=1)
level3: Upvaldesc列表有4个,第一个是_ENV, 是上一级的上值列表的第一个(所以in_stack=0,idx=0); 第二个是变量a, 是上一级的上值列表的第二个(所以in_stack=0,idx=1);第三个是变量b, 是上一级的上值列表的第三个(所以in_stack=0,idx=2);第四个是变量c,是上一级局部变量在栈上第一个(所以in_stack=1,idx=0)

上值生成(运行时)

当加载这段代码块时,level2的upval列表会加入2个UpVal,指向栈(变量a和b);level3的UpVal不会生成因为没有调用xxx
在这里插入图片描述
当调用xxx时,最终生成的upval列表如下
在这里插入图片描述

上值的open和close

如下图的代码段,当调用aaa()时,var1和var2都在栈上,处于open状态,UpVal结构的v指针指向栈上数据
在这里插入图片描述
但是aaa调用完毕,var2会被回收,弹出栈,如下:
在aaa函数执行完毕时,他们的UpVal实例,会进行close操作,什么意思呢,就是原来的upval->v指向栈的某个位置,现在这个关联将被破除,并且upval->v的值,赋值为upval->u.value的地址,同时,upval->v原来指向的值,会被赋值到upval->u.value上(绿色框2个UpVal指向了新的空间)
在这里插入图片描述

闭包共享/不共享上值

f1和f2分别创建了一个闭包实例,var1是top level的局部变量,能共享;var2则是独立上值,且在aaa()调用完毕后会从栈上移除,转为close状态(可以看到var2的UpVal结构,v指针不是指向栈,而是union中的TValue结构)
在这里插入图片描述

### 闭包的基本概念 在 Lua 中,**闭包(Closure)** 是一个能够访问和记住其词法作用域的函数。由于 Lua 将函数视为第一类值,函数可以像其他数据类型一样被传递和赋值,这使得闭包的创建变得非常自然 [^1]。 从更深层次来看,可以把函数原型理解为“类”,而闭包则是这个类的一个实例。无论何时将函数赋值给变量,Lua 都会生成一个新的闭包对象,即使它没有使用任何外部变量(即上值 upvalue)。这意味着每次调用都会产生独立的闭包对象 [^2]。 --- ### 闭包的结构与行为 闭包由函数及其捕获的外部环境组成。例如,当一个函数引用了外部作用域中的变量时,该变量被称为 **upvalue**,并被闭包所持有。这种机制允许函数在其定义的作用域之外继续访问这些变量 [^3]。 #### 示例:基本闭包 ```lua function counter() local count = 0 return function() count = count + 1 return count end end local c1 = counter() print(c1()) -- 输出: 1 print(c1()) -- 输出: 2 ``` 在这个例子中,`count` 是 `counter` 函数内部的局部变量,但它被返回的闭包所捕获,并在每次调用时保持状态。 --- ### 闭包的使用场景 闭包广泛用于以下场景: - **回调函数**:在事件驱动编程中,如 GUI 框架或网络请求。 - **封装状态**:实现私有变量和方法。 - **柯里化与部分应用**:通过绑定参数生成新的函数。 - **延迟执行**:将逻辑封装在闭包中,稍后执行。 #### 示例:避免重复创建闭包 为了减少内存开销,可以在高频调用的场景下缓存闭包: ```lua function handler(obj, method) if not obj.__handlerMap then obj.__handlerMap = {} end if obj.__handlerMap[method] == nil then obj.__handlerMap[method] = function(...) return method(obj, ...) end end return obj.__handlerMap[method] end ``` --- ### 闭包的潜在问题 虽然闭包功能强大,但也存在一些需要注意的问题: - **内存泄漏风险**:如果闭包长时间持有对某些变量的引用,可能导致这些变量无法被垃圾回收器释放 [^4]。 - **意外共享变量**:在循环中创建闭包时,所有闭包可能共享同一个变量,而不是各自拥有独立副本 [^5]。 #### 示例:循环中闭包共享变量问题 ```lua local functions = {} for i = 1, 3 do functions[i] = function() return i end end for j = 1, 3 do print(functions[j]()) -- 输出: 4 4 4 end ``` 为了避免这种情况,可以通过引入中间函数来捕获当前的变量值: ```lua local functions = {} for i = 1, 3 do functions[i] = (function(x) return function() return x end end)(i) end for j = 1, 3 do print(functions[j]()) -- 输出: 1 2 3 end ``` --- ### 总结 闭包Lua 编程中非常强大的特性,它结合了函数和状态,提供了灵活的控制流和数据封装方式。然而,开发者需要理解其工作机制,特别是在内存管理和变量生命周期方面,以避免潜在的性能问题和逻辑错误 [^1][^2][^3][^4][^5]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值