变量的共享范围

    先看两段代码：

    local self.jsonp = self.args.jsonp local keyList = string.split(self.args.key_list, ‘,’) for i=1, #keyList do — do something ngx.say(self.args.kind) end

    showJs(self.jsonp, valList)

    2. 大概代码逻辑如上，在生产服务器中做测试，出现了下面的情况：
    4. > 注： 自己测试的参数是 `?jsonp=jsonp1435220570933`，而用户的请求基本上都是 `?jsonp=jquery....`
    6. **测试场景 1、仅自己测试**
    7. 如果没有用户访问，自己几个人测试，一切正常。
    9. **测试场景 2、接入大量的用户请求**
    10. 我将大量的用户请求接入后，继续测试，在不停地刷新页面的时候会出现以下情况（概率也不低，几分之一，大于 10%）：
    11. - 输出的 callback 和 URL 地址中参数不一致。（callback 来源于 self.jsonp，即 URL 参数中的 jsonp 变量。）
    13.     表现为：出现了用户请求才会有的 `jquery....` 这种字符串。
    14. - 另外 URL 参数中的 kind 是 1，我在循环中的输出会有 “1” 或 `nil` 的情况。
    16. 不仅这两种参数，几乎所有 URL 中传递的参数，都有可能变成其他请求链接中的参数。
    18. 基于以上情况，个人猜想会不会是在生产服务器大量用户请求中，不同请求参数串掉了？
    19. 如果不是这样，不应该出现我获取的参数是某个其他用户的值。 for 循环中的值也应该固定的，而不应该一会儿是我自己请求中的参数值，一会儿是其他用户请求中的参数值。
    21. ### 问题出在哪里？
    24. `mo.args` 变量 **一不留神全局共享了**，而这肯定不是作者期望的。所以导致了高并发应用场景下偶尔出现异常错误的情况。
    26. 每个请求的数据在传递和存储时须特别小心，只应通过你自己的函数参数来传递，或者通过 ngx.ctx 表。前者效率显然较高，而后者胜在能跨阶段使用。
    28. 贴一个 ngx.ctx 的例子：
    30. ```nginx
    31. location /test {
    32.     rewrite_by_lua_block {
    34.     }
    36.     access_by_lua_block {
    37.         ngx.ctx.foo = ngx.ctx.foo + 3
    38.     }
    40.     content_by_lua_block {
    41.         ngx.say(ngx.ctx.foo)
    42.     }
    43. }

    全局变量

    在 OpenResty 里面，只有在 init_by_lua* 和 init_worker_by_lua* 阶段才能定义真正的全局变量。 这是因为其他阶段里面，OpenResty 会设置一个隔离的全局变量表，以免在处理过程污染了其他请求。 即使在上述两个可以定义全局变量的阶段，也尽量避免这么做。全局变量能解决的问题，用模块变量也能解决，而且会更清晰、更干净。

    模块变量

    由于 Lua VM 会把 require 进来的模块缓存到 package.loaded 表里，除非设置了 lua_code_cache off，模块里定义的变量都会被缓存起来。而且重要的是，模块变量在每个请求中是共享的。

    模块变量的跨请求特性，可以有很多用途。比如在变量间共享值，或者在 init_worker_by_lua* 中初始化全局用到的数值。作为硬币的反面，无视这一特性也会带来许多问题。下面让我们看看一个例子。

    if var.calc() == 1 then ngx.say(“ok”) else ngx.status = ngx.HTTP_INTERNAL_SERVER_ERROR ngx.say(“error”) end

    2. > `var.lua` 文件
    3. ```lua
    4. local count = 1
    7. local function add()
    8.     count = count + 1
    9. end
    11. local function sub()
    12.     count = count - 1
    13. end
    16.     add()
    17.     -- 模拟协程调度
    18.     ngx.sleep(ngx.time()%0.003)
    19.     sub()
    20.     return count
    21. end
    23. return _M

    分别用单个客户端和两个客户端请求之:

    1. coroutine A | coroutine B | count
    2. add         |             | 2
    3. sleep       |             | 2
    4.             | add         | 3
    5.             | sleep       | 3
    6. sub         |             | 2
    8. (2 != 1) => HTTP_INTERNAL_SERVER_ERROR!

    同样道理，如果在模块级别共享 TCP/UDP Client，比如在模块开头 local httpc = http.new()，高并发下难免会有奇怪的问题。把 httpc:send 看作 add；httpc:receive 看作 sub，几乎就是上述的例子。 运气好的话，你可能只会碰到一个 bad request 的异常；运气不好，就是一个潜在的坑。

    本地变量

    跟全局变量、模块变量相对，这里我们姑且把 *_by_lua* 里面定义的变量称之为本地变量。 本地变量仅在当前阶段有效，如果要跨阶段使用，需要借助 ngx.ctx 或者附加在模块变量里。

    值得注意的是 ngx.timer.*。虽然 timer 代码占的是别的上下文的位置，但是每个 timer 都是运行在自己的协程里面，里面定义的变量都是协程内部的。

    举个例子，让我们在 init_worker_by_lua_block 里面定义一个 timer。

    counter 变量初看是定义在 init_worker_by_lua* 的全局变量。定义在 init_worker_by_lua* 阶段，没有 local 修饰，根据前面的讨论，它肯定是个全局变量嘛。

    运行一下，你会发现，每次 counter 的输出都是 1。

    • 2、把要共享的变量当作模块变量。

    （当然也可以选择在 里面、ngx.timer.* 外面定义真正的全局变量，不过不太推荐罢了）