使用ngx.semaphore时参数如何传递

humphery.yu

示例：

local globalVar ...

location = /t {

content_by_lua_block {

local semaphore = require "ngx.semaphore"

local sema = semaphore.new()

local function handler()

ngx.say("sub thread: waiting on sema...")

local ok, err = sema:wait(1) -- wait for a second at most

if not ok then

ngx.say("sub thread: failed to wait on sema: ", err)

else

ngx.say(globalVar["var"])

end

local co = ngx.thread.spawn(handler)

globalVar["test"]={sema:sema}

}

location = /o {

content_by_lua_block {

local sema = globalVar["test"]

globalVar["var"]="1"

sema:post(1)

globalVar["var"]="2"

sema:post(1)

}

如连续调用/o返回值应是多少？

/t 和 /o 先后顺序是怎样的？

yuansheng

On Wed, Mar 16, 2016 at 5:03 PM, humphery <humph...@gmail.com> wrote:
> rt
>
> 示例：
>
> local globalVar ...
>
> location = /t {
>     content_by_lua_block {
>         local semaphore = require "ngx.semaphore"
>         local sema = semaphore.new()
>
>         local function handler()
>             ngx.say("sub thread: waiting on sema...")
>
>             local ok, err = sema:wait(1)  -- wait for a second at most
>             if not ok then
>                 ngx.say("sub thread: failed to wait on sema: ", err)
>             else
>                 ngx.say(globalVar["var"])
>             end
>         end
>
>         local co = ngx.thread.spawn(handler)
>
>         globalVar["test"]={sema:sema}
>     }
> }
>
> location = /o {
>     content_by_lua_block {
>         local sema = globalVar["test"]
> globalVar["var"]="1"
>         sema:post(1)
>         globalVar["var"]="2"
>         sema:post(1)
>     }
> }

对于 sem 的共享，应该使用
https://github.com/iresty/nginx-lua-module-zh-wiki#data-sharing-within-an-nginx-worker
类方法。谁先引用的，如果发现 sem 为空，先创建一下。

>
> 如连续调用/o返回值应是多少？
> /t 和 /o 先后顺序是怎样的？
>
> --

按照上面的连接用法，没有先后顺序一说，谁先谁后可以的（这个 API 我还没深入使用，说错了 @doujiang 批评指正）。

> -- 

YuanSheng Wang
---------------------------------------
My Github: https://github.com/membphis
OpenResty lover ^_^

doujiang24

Hello,

2016-03-16 17:03 GMT+08:00 humphery <humph...@gmail.com>:

rt

示例：

local globalVar ...

首先假定你这个是按照院生的意思来实现的

location = /t {
content_by_lua_block {
local semaphore = require "ngx.semaphore"
local sema = semaphore.new()

local function handler()
ngx.say("sub thread: waiting on sema...")

local ok, err = sema:wait(1) -- wait for a second at most

这里没必要放入一个 thread，直接在当前主 thread 里 wait 即可

if not ok then
ngx.say("sub thread: failed to wait on sema: ", err)
else
ngx.say(globalVar["var"])
end
end

local co = ngx.thread.spawn(handler)

globalVar["test"]={sema:sema}

你这里貌似跟下面对不上

}
}

location = /o {
content_by_lua_block {
local sema = globalVar["test"]
globalVar["var"]="1"
sema:post(1)
globalVar["var"]="2"
sema:post(1)
}
}

如连续调用/o返回值应是多少？
/t 和 /o 先后顺序是怎样的？

这个问的没看懂，我猜你想问的是 /t 的输出？

答案是为 2，因为 sem:post 不会让出当前协程的执行权，也就是 wait 不会立马执行

https://github.com/openresty/lua-resty-core/blob/master/lib/ngx/semaphore.md#post

另外，我想多看文档，自己动手实践一下或许是个更好的办法 :)

--

humphery.yu

>> globalVar["test"]={sema:sema}

>> 你这里貌似跟下面对不上

不好意思手误，应是globalVar["test"]=sema

上述问题缺少了应用上下文：

是关于客户端消息互发问题：用户1连接到ngx后（/t）,用户2对用户1发送消息（/o）,这就需要解决消息的传递，我的疑问是，当把消息存放在全局变量时，如果用户2并发的发送N个消息时，在/t的“handler方法内语句执行会不会被中断”？，如：

1 local function handler()

2 ngx.say("sub thread: waiting on sema...")

4 local ok, err = sema:wait(1) -- wait for a second at most

5 globalVar["var"]=globalVar["var"]+1

6 ngx.say(globalVar["var"])

7 end

假设语句被执行到第5行时，被中断交出执行权，进而执行了/o,这时第6再获取执行权时其值是不可预知的（/o中可能会对globalVar["var"]赋预任意数值）

不知道我的疑问表述清楚了没有

在 2016年3月16日星期三 UTC+8下午9:54:56，doujiang写道：

Hello,

2016-03-16 17:03 GMT+08:00 humphery <humph...@gmail.com>:
rt

示例：

local globalVar ...

首先假定你这个是按照院生的意思来实现的

location = /t {
content_by_lua_block {
local semaphore = require "ngx.semaphore"
local sema = semaphore.new()

local function handler()
ngx.say("sub thread: waiting on sema...")

local ok, err = sema:wait(1) -- wait for a second at most

这里没必要放入一个 thread，直接在当前主 thread 里 wait 即可

if not ok then
ngx.say("sub thread: failed to wait on sema: ", err)
else
ngx.say(globalVar["var"])
end
end

local co = ngx.thread.spawn(handler)

globalVar["test"]={sema:sema}

你这里貌似跟下面对不上

}
}

location = /o {
content_by_lua_block {
local sema = globalVar["test"]
globalVar["var"]="1"
sema:post(1)
globalVar["var"]="2"
sema:post(1)
}
}

如连续调用/o返回值应是多少？
/t 和 /o 先后顺序是怎样的？

这个问的没看懂，我猜你想问的是 /t 的输出？
答案是为 2，因为 sem:post 不会让出当前协程的执行权，也就是 wait 不会立马执行

https://github.com/openresty/lua-resty-core/blob/master/lib/ngx/semaphore.md#post

另外，我想多看文档，自己动手实践一下或许是个更好的办法 :)

--

doujiang24

Hello,

在 2016年3月17日上午10:56，humphery <humph...@gmail.com>写道：

上述问题缺少了应用上下文：
是关于客户端消息互发问题：用户1连接到ngx后（/t）,用户2对用户1发送消息（/o）,这就需要解决消息的传递，我的疑问是，当把消息存放在全局变量时，

备注：这个全局变量，仅仅是当前 worker，ngx.semaphore 也是不能跨 worker 的

如果用户2并发的发送N个消息时，在/t的“handler方法内语句执行会不会被中断”？，如：
1 local function handler()
2 ngx.say("sub thread: waiting on sema...")
3
4 local ok, err = sema:wait(1) -- wait for a second at most
5 globalVar["var"]=globalVar["var"]+1
6 ngx.say(globalVar["var"])
7 end
假设语句被执行到第5行时，被中断交出执行权，进而执行了/o,这时第6再获取执行权时其值是不可预知的（/o中可能会对globalVar["var"]赋预任意数值）

如果你仔细看我上篇回复的话，应该已经知道答案了

a = a + 1

sem:post()

a = a + 1

sem:post()

这是一个原子操作，中间不会有任何中断，所以，实际上等效于：

a = a + 2

sem:post(2)

post 只做两件事情：[1]

1. 资源数 + 1

2. 在 nginx 事件队列里加入一个事件（如果当前 sema 有人在 wait 的话）

sem:wait 当没有资源的时候，或者已经有人在等待的时候，会让出当前协程执行权（如果有资源，立马就返回了，不会让出）[2]

那么，post 操作加入的资源，什么时候会被 wait 拿到呢？就是 post 操作加入 nginx 的事件，被 nginx 执行的时候

协程是不会被强制中断的，只有自己主动让出执行权

1) post 永远不会让出执行权

2) wait 可能会让出执行权

其实这些在文档里都有，这个就当中文翻译了吧

1. https://github.com/openresty/lua-nginx-module/blob/master/src/ngx_http_lua_semaphore.c#L307

2. https://github.com/openresty/lua-nginx-module/blob/master/src/ngx_http_lua_semaphore.c#L328

不知道我的疑问表述清楚了没有

在 2016年3月16日星期三 UTC+8下午9:54:56，doujiang写道：
Hello,

2016-03-16 17:03 GMT+08:00 humphery <humph...@gmail.com>:
rt

示例：

local globalVar ...

首先假定你这个是按照院生的意思来实现的

location = /t {
content_by_lua_block {
local semaphore = require "ngx.semaphore"
local sema = semaphore.new()

local function handler()
ngx.say("sub thread: waiting on sema...")

local ok, err = sema:wait(1) -- wait for a second at most

这里没必要放入一个 thread，直接在当前主 thread 里 wait 即可

if not ok then
ngx.say("sub thread: failed to wait on sema: ", err)
else
ngx.say(globalVar["var"])
end
end

local co = ngx.thread.spawn(handler)

globalVar["test"]={sema:sema}

你这里貌似跟下面对不上

}
}

location = /o {
content_by_lua_block {
local sema = globalVar["test"]
globalVar["var"]="1"
sema:post(1)
globalVar["var"]="2"
sema:post(1)
}
}

如连续调用/o返回值应是多少？
/t 和 /o 先后顺序是怎样的？

这个问的没看懂，我猜你想问的是 /t 的输出？
答案是为 2，因为 sem:post 不会让出当前协程的执行权，也就是 wait 不会立马执行

https://github.com/openresty/lua-resty-core/blob/master/lib/ngx/semaphore.md#post

另外，我想多看文档，自己动手实践一下或许是个更好的办法 :)

--

--