关于ngx.var.VARIABLE的对per-request memory pool的资源消耗问题

yunthanatos

文档中：

WARNING When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination. So when you need to read from an Nginx variable repeatedly in your Lua code, cache the Nginx variable value to your own Lua variable

前提：

如果每个worker只在第一个请求处对ngx.var.VARIABLE进行一次读操作

后续所有请求不再读写ngx.var.VARIABLE

问题：

后续请求中的per-request memory pool还会为这个ngx.var.VARIABLE分配内存吗？

yunthanatos

这个问题的根源：

想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数

但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

在 2015年7月30日星期四 UTC+8下午5:45:00，Yun Thanatos写道：

文档中：

WARNING When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination. So when you need to read from an Nginx variable repeatedly in your Lua code, cache the Nginx variable value to your own Lua variable

前提：
如果每个worker只在第一个请求处对ngx.var.VARIABLE进行一次读操作
后续所有请求不再读写ngx.var.VARIABLE

问题：
后续请求中的per-request memory pool还会为这个ngx.var.VARIABLE分配内存吗？

membphis

> 想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数

> 但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

只要这些变量本身不要存储特别大的内容，就没问题。这些变量的有效期是绑定在会话上的，会话结束，变量占用的内存资源也都会被释放。

原文：

When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination

我的理解，欢迎一起交流。

2015-07-30 17:50 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:

这个问题的根源：

想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数

但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

在 2015年7月30日星期四 UTC+8下午5:45:00，Yun Thanatos写道：
文档中：

WARNING When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination. So when you need to read from an Nginx variable repeatedly in your Lua code, cache the Nginx variable value to your own Lua variable

前提：
如果每个worker只在第一个请求处对ngx.var.VARIABLE进行一次读操作
后续所有请求不再读写ngx.var.VARIABLE

问题：
后续请求中的per-request memory pool还会为这个ngx.var.VARIABLE分配内存吗？

--

Membhis

My github: https://github.com/membphis

Our Book: OpenResty Best Practices

yunthanatos

这些变量的有效期是绑定在会话上的，会话结束，变量占用的内存资源也都会被释放。

这点同意 :)

这里隐藏了一面如果一个request根本就没有读写这些变量 per-request-memory-pool还会为其分配内存吗？

在 2015年7月30日星期四 UTC+8下午5:57:13，YuanSheng Wang写道：

> 想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数
> 但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

只要这些变量本身不要存储特别大的内容，就没问题。这些变量的有效期是绑定在会话上的，会话结束，变量占用的内存资源也都会被释放。

原文：
When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination

我的理解，欢迎一起交流。

2015-07-30 17:50 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:
这个问题的根源：

想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数

但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

在 2015年7月30日星期四 UTC+8下午5:45:00，Yun Thanatos写道：
文档中：

WARNING When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination. So when you need to read from an Nginx variable repeatedly in your Lua code, cache the Nginx variable value to your own Lua variable

前提：
如果每个worker只在第一个请求处对ngx.var.VARIABLE进行一次读操作
后续所有请求不再读写ngx.var.VARIABLE

问题：
后续请求中的per-request memory pool还会为这个ngx.var.VARIABLE分配内存吗？

--

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

yunthanatos

我的猜测是不会分配但目前还无证明 ;)

在 2015年7月30日星期四 UTC+8下午5:57:13，YuanSheng Wang写道：

> 想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数
> 但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

只要这些变量本身不要存储特别大的内容，就没问题。这些变量的有效期是绑定在会话上的，会话结束，变量占用的内存资源也都会被释放。

原文：
When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination

我的理解，欢迎一起交流。

2015-07-30 17:50 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:
这个问题的根源：

想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数

但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

在 2015年7月30日星期四 UTC+8下午5:45:00，Yun Thanatos写道：
文档中：

WARNING When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination. So when you need to read from an Nginx variable repeatedly in your Lua code, cache the Nginx variable value to your own Lua variable

前提：
如果每个worker只在第一个请求处对ngx.var.VARIABLE进行一次读操作
后续所有请求不再读写ngx.var.VARIABLE

问题：
后续请求中的per-request memory pool还会为这个ngx.var.VARIABLE分配内存吗？

--

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

membphis

> 这里隐藏了一面如果一个request根本就没有读写这些变量 per-request-memory-pool还会为其分配内存吗？

当然需要了。机器是笨的。只要你set，就一定会分配存储区。因为我们后面可以加载lua脚本，nginx自己根本无法判断我们内部是否会读写这个变量，无法做这个调优。

2015-07-30 18:30 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:

我的猜测是不会分配但目前还无证明 ;)

在 2015年7月30日星期四 UTC+8下午5:57:13，YuanSheng Wang写道：
> 想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数
> 但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

只要这些变量本身不要存储特别大的内容，就没问题。这些变量的有效期是绑定在会话上的，会话结束，变量占用的内存资源也都会被释放。

原文：
When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination

我的理解，欢迎一起交流。

2015-07-30 17:50 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:
这个问题的根源：

想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数

但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

在 2015年7月30日星期四 UTC+8下午5:45:00，Yun Thanatos写道：
文档中：

WARNING When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination. So when you need to read from an Nginx variable repeatedly in your Lua code, cache the Nginx variable value to your own Lua variable

前提：
如果每个worker只在第一个请求处对ngx.var.VARIABLE进行一次读操作
后续所有请求不再读写ngx.var.VARIABLE

问题：
后续请求中的per-request memory pool还会为这个ngx.var.VARIABLE分配内存吗？

--

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

Membhis

My github: https://github.com/membphis

Our Book: OpenResty Best Practices

yunthanatos

应该有两种实现方法：

1. 当request读写时为其分配

2. 只要request来了就为其分配

如果是第二种的话

wiki中：

to prevent (temporary) memory leaking within the current request's lifetime. Another way of caching the result is to use the ngx.ctx table.

This API requires a relatively expensive metamethod call and it is recommended to avoid using it on hot code paths.

为什么还需要这样操作呢？直接引用不就可以了吗？

在 2015年7月30日星期四 UTC+8下午6:35:04，YuanSheng Wang写道：

> 这里隐藏了一面如果一个request根本就没有读写这些变量 per-request-memory-pool还会为其分配内存吗？

当然需要了。机器是笨的。只要你set，就一定会分配存储区。因为我们后面可以加载lua脚本，nginx自己根本无法判断我们内部是否会读写这个变量，无法做这个调优。

2015-07-30 18:30 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:

我的猜测是不会分配但目前还无证明 ;)

在 2015年7月30日星期四 UTC+8下午5:57:13，YuanSheng Wang写道：
> 想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数
> 但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

只要这些变量本身不要存储特别大的内容，就没问题。这些变量的有效期是绑定在会话上的，会话结束，变量占用的内存资源也都会被释放。

原文：
When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination

我的理解，欢迎一起交流。

2015-07-30 17:50 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:
这个问题的根源：

想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数

但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

在 2015年7月30日星期四 UTC+8下午5:45:00，Yun Thanatos写道：
文档中：

WARNING When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination. So when you need to read from an Nginx variable repeatedly in your Lua code, cache the Nginx variable value to your own Lua variable

前提：
如果每个worker只在第一个请求处对ngx.var.VARIABLE进行一次读操作
后续所有请求不再读写ngx.var.VARIABLE

问题：
后续请求中的per-request memory pool还会为这个ngx.var.VARIABLE分配内存吗？

--

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

membphis

我觉得你混淆了这两种变量，他们是不一样的。

ngx.var.VARIABLE

这里存放的都是nginx内置变量+配置产生的变量，而是每个请求信息解析后的结果。他们都是nginx内置变量。

清单：http://blog.csdn.net/iinel/article/details/4321383

ngx.ctx

这里存放的，全部都是用户Lua自定义变量，是专门给ngx-lua用户使用的。

看一个官方例子：

 location /test {
        rewrite_by_lua '
            ngx.ctx.foo = 76
        ';
        access_by_lua '
            ngx.ctx.foo = ngx.ctx.foo + 3
        ';
        content_by_lua '
            ngx.say(ngx.ctx.foo)
        ';
    }

2015-07-30 20:54 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:

应该有两种实现方法：
1. 当request读写时为其分配
2. 只要request来了就为其分配

如果是第二种的话
wiki中：

to prevent (temporary) memory leaking within the current request's lifetime. Another way of caching the result is to use the ngx.ctx table.
This API requires a relatively expensive metamethod call and it is recommended to avoid using it on hot code paths.

为什么还需要这样操作呢？直接引用不就可以了吗？

在 2015年7月30日星期四 UTC+8下午6:35:04，YuanSheng Wang写道：
> 这里隐藏了一面如果一个request根本就没有读写这些变量 per-request-memory-pool还会为其分配内存吗？

当然需要了。机器是笨的。只要你set，就一定会分配存储区。因为我们后面可以加载lua脚本，nginx自己根本无法判断我们内部是否会读写这个变量，无法做这个调优。

2015-07-30 18:30 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:

我的猜测是不会分配但目前还无证明 ;)

在 2015年7月30日星期四 UTC+8下午5:57:13，YuanSheng Wang写道：
> 想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数
> 但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

只要这些变量本身不要存储特别大的内容，就没问题。这些变量的有效期是绑定在会话上的，会话结束，变量占用的内存资源也都会被释放。

原文：
When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination

我的理解，欢迎一起交流。

2015-07-30 17:50 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:
这个问题的根源：

想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数

但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

在 2015年7月30日星期四 UTC+8下午5:45:00，Yun Thanatos写道：
文档中：

WARNING When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination. So when you need to read from an Nginx variable repeatedly in your Lua code, cache the Nginx variable value to your own Lua variable

前提：
如果每个worker只在第一个请求处对ngx.var.VARIABLE进行一次读操作
后续所有请求不再读写ngx.var.VARIABLE

问题：
后续请求中的per-request memory pool还会为这个ngx.var.VARIABLE分配内存吗？

--

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

Membhis

My github: https://github.com/membphis

Our Book: OpenResty Best Practices

yunthanatos

多谢YuanSheng的解惑！

另外我还有一个问题想请教YuanSheng：

我现在在开发一个ngx lua模块 (nginx.conf中配置了很多虚拟server项)

这个模块的功能就是: 分别统计各hostname访问频数与时间戳等信息并将其定期dump到一个文件中

现在遇到的一个问题就是：

运维小组要求日志文件路径应该写在nginx.conf文件中 以便于管理

但是目前的做法是直接以全局变量的形式定义在了init_by_lua_file文件中现在如何修改以满足运维小组的要求呢？

1.set $var 形式 (需要在每个server段中都加上？这种方式在server有很多的时候不可行)

2.使用init_by_lua将参数直接写在lua语句中 (影响conf的整体协调性)

目前我还没有想到比较好的方法不知道YuanSheng怎么看这样的问题呢？

在 2015年7月30日星期四 UTC+8下午10:36:06，YuanSheng Wang写道：

我觉得你混淆了这两种变量，他们是不一样的。

ngx.var.VARIABLE

这里存放的都是nginx内置变量+配置产生的变量，而是每个请求信息解析后的结果。他们都是nginx内置变量。

清单：http://blog.csdn.net/iinel/article/details/4321383

ngx.ctx

这里存放的，全部都是用户Lua自定义变量，是专门给ngx-lua用户使用的。

看一个官方例子：
 location /test {
        rewrite_by_lua '
            ngx.ctx.foo = 76
        ';
        access_by_lua '
            ngx.ctx.foo = ngx.ctx.foo + 3
        ';
        content_by_lua '
            ngx.say(ngx.ctx.foo)
        ';
    }
2015-07-30 20:54 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:
应该有两种实现方法：
1. 当request读写时为其分配
2. 只要request来了就为其分配

如果是第二种的话
wiki中：

to prevent (temporary) memory leaking within the current request's lifetime. Another way of caching the result is to use the ngx.ctx table.
This API requires a relatively expensive metamethod call and it is recommended to avoid using it on hot code paths.

为什么还需要这样操作呢？直接引用不就可以了吗？

在 2015年7月30日星期四 UTC+8下午6:35:04，YuanSheng Wang写道：
> 这里隐藏了一面如果一个request根本就没有读写这些变量 per-request-memory-pool还会为其分配内存吗？

当然需要了。机器是笨的。只要你set，就一定会分配存储区。因为我们后面可以加载lua脚本，nginx自己根本无法判断我们内部是否会读写这个变量，无法做这个调优。

2015-07-30 18:30 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:

我的猜测是不会分配但目前还无证明 ;)

在 2015年7月30日星期四 UTC+8下午5:57:13，YuanSheng Wang写道：
> 想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数
> 但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

只要这些变量本身不要存储特别大的内容，就没问题。这些变量的有效期是绑定在会话上的，会话结束，变量占用的内存资源也都会被释放。

原文：
When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination

我的理解，欢迎一起交流。

2015-07-30 17:50 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:
这个问题的根源：

想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数

但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

在 2015年7月30日星期四 UTC+8下午5:45:00，Yun Thanatos写道：
文档中：

WARNING When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination. So when you need to read from an Nginx variable repeatedly in your Lua code, cache the Nginx variable value to your own Lua variable

前提：
如果每个worker只在第一个请求处对ngx.var.VARIABLE进行一次读操作
后续所有请求不再读写ngx.var.VARIABLE

问题：
后续请求中的per-request memory pool还会为这个ngx.var.VARIABLE分配内存吗？

--

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

membphis

按照你说的需求，我觉得可以这样玩。

有关最后记录日志部分，可以在server上的access、rewrite阶段完成你的日志信息采集、记录工作。

lua_shared_dict dict 1m;

init_by_lua '

local dict = ngx.shared.dict;

dict:set("path", "/path/log/dump.log")

server {

location = /api {

content_by_lua '

local dict = ngx.shared.dict;

local log_path = dict:get("path")

-- write your log to log_path

}

代码借鉴：http://wiki.nginx.org/HttpLuaModule#init_by_lua

2015-07-30 23:00 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:

多谢YuanSheng的解惑！

另外我还有一个问题想请教YuanSheng：

我现在在开发一个ngx lua模块 (nginx.conf中配置了很多虚拟server项)

这个模块的功能就是: 分别统计各hostname访问频数与时间戳等信息并将其定期dump到一个文件中

现在遇到的一个问题就是：

运维小组要求日志文件路径应该写在nginx.conf文件中 以便于管理

但是目前的做法是直接以全局变量的形式定义在了init_by_lua_file文件中现在如何修改以满足运维小组的要求呢？

1.set $var 形式 (需要在每个server段中都加上？这种方式在server有很多的时候不可行)

2.使用init_by_lua将参数直接写在lua语句中 (影响conf的整体协调性)
目前我还没有想到比较好的方法不知道YuanSheng怎么看这样的问题呢？
在 2015年7月30日星期四 UTC+8下午10:36:06，YuanSheng Wang写道：
我觉得你混淆了这两种变量，他们是不一样的。

ngx.var.VARIABLE

这里存放的都是nginx内置变量+配置产生的变量，而是每个请求信息解析后的结果。他们都是nginx内置变量。

清单：http://blog.csdn.net/iinel/article/details/4321383

ngx.ctx

这里存放的，全部都是用户Lua自定义变量，是专门给ngx-lua用户使用的。

看一个官方例子：
location /test { rewrite_by_lua ' ngx.ctx.foo = 76 '; access_by_lua ' ngx.ctx.foo = ngx.ctx.foo + 3 '; content_by_lua ' ngx.say(ngx.ctx.foo) '; }

2015-07-30 20:54 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:
应该有两种实现方法：
1. 当request读写时为其分配
2. 只要request来了就为其分配

如果是第二种的话
wiki中：

to prevent (temporary) memory leaking within the current request's lifetime. Another way of caching the result is to use the ngx.ctx table.
This API requires a relatively expensive metamethod call and it is recommended to avoid using it on hot code paths.

为什么还需要这样操作呢？直接引用不就可以了吗？

在 2015年7月30日星期四 UTC+8下午6:35:04，YuanSheng Wang写道：
> 这里隐藏了一面如果一个request根本就没有读写这些变量 per-request-memory-pool还会为其分配内存吗？

当然需要了。机器是笨的。只要你set，就一定会分配存储区。因为我们后面可以加载lua脚本，nginx自己根本无法判断我们内部是否会读写这个变量，无法做这个调优。

2015-07-30 18:30 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:

我的猜测是不会分配但目前还无证明 ;)

在 2015年7月30日星期四 UTC+8下午5:57:13，YuanSheng Wang写道：
> 想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数
> 但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

只要这些变量本身不要存储特别大的内容，就没问题。这些变量的有效期是绑定在会话上的，会话结束，变量占用的内存资源也都会被释放。

原文：
When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination

我的理解，欢迎一起交流。

2015-07-30 17:50 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:
这个问题的根源：

想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数

但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

在 2015年7月30日星期四 UTC+8下午5:45:00，Yun Thanatos写道：
文档中：

WARNING When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination. So when you need to read from an Nginx variable repeatedly in your Lua code, cache the Nginx variable value to your own Lua variable

前提：
如果每个worker只在第一个请求处对ngx.var.VARIABLE进行一次读操作
后续所有请求不再读写ngx.var.VARIABLE

问题：
后续请求中的per-request memory pool还会为这个ngx.var.VARIABLE分配内存吗？

--

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

Membhis

My github: https://github.com/membphis

Our Book: OpenResty Best Practices

doujiang24

在 2015年7月30日下午8:54，Yun Thanatos <yunth...@gmail.com>写道：

应该有两种实现方法：
1. 当request读写时为其分配
2. 只要request来了就为其分配

针对 ngx.var 确实有两种，但是你这种 set 指令声明的的变量，是第二种

如果是第二种的话
wiki中：

to prevent (temporary) memory leaking within the current request's lifetime. Another way of caching the result is to use the ngx.ctx table.
This API requires a relatively expensive metamethod call and it is recommended to avoid using it on hot code paths.

为什么还需要这样操作呢？直接引用不就可以了吗？

对于被索引了的变量（set $var XX 这种即是），确实是直接引用的，所以 get 这个变量是不会消耗内存池

但是很多 nginx 内建变量，例如 YuanSheng 提到的，是未被索引的变量，他们是通过取程序动态拿的 [1]，所以每次需要从内存池申请一个结构体

ngx.var get 操作是调用的 ngx_http_get_variable 这个 nginx 函数，详情你可以看代码 [2]

1. http://openresty.org/download/agentzh-nginx-tutorials-zhcn.html#01-NginxVariables03

2. http://agentzh.org/misc/code/nginx/http/ngx_http_variables.c.html#L547

在 2015年7月30日星期四 UTC+8下午6:35:04，YuanSheng Wang写道：
> 这里隐藏了一面如果一个request根本就没有读写这些变量 per-request-memory-pool还会为其分配内存吗？

当然需要了。机器是笨的。只要你set，就一定会分配存储区。因为我们后面可以加载lua脚本，nginx自己根本无法判断我们内部是否会读写这个变量，无法做这个调优。

2015-07-30 18:30 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:

我的猜测是不会分配但目前还无证明 ;)

在 2015年7月30日星期四 UTC+8下午5:57:13，YuanSheng Wang写道：
> 想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数
> 但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

只要这些变量本身不要存储特别大的内容，就没问题。这些变量的有效期是绑定在会话上的，会话结束，变量占用的内存资源也都会被释放。

原文：
When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination

我的理解，欢迎一起交流。

2015-07-30 17:50 GMT+08:00 Yun Thanatos <yunth...@gmail.com>:
这个问题的根源：

想通过 nginx.conf : set $mod_var "true"; 的方式向ngx lua module传递初始化参数

但是过多的ngx.var.VARIABLE定义是否会影响最终服务的内存消耗量?

在 2015年7月30日星期四 UTC+8下午5:45:00，Yun Thanatos写道：
文档中：

WARNING When reading from an Nginx variable, Nginx will allocate memory in the per-request memory pool which is freed only at request termination. So when you need to read from an Nginx variable repeatedly in your Lua code, cache the Nginx variable value to your own Lua variable

前提：
如果每个worker只在第一个请求处对ngx.var.VARIABLE进行一次读操作
后续所有请求不再读写ngx.var.VARIABLE

问题：
后续请求中的per-request memory pool还会为这个ngx.var.VARIABLE分配内存吗？

--

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

--

Membhis
My github: https://github.com/membphis
Our Book: OpenResty Best Practices

--