crasyangel.lhy

不是，worker.id取的是worker_num，而worker_number是spwan_worker传进来的i，而不是slot

在 2016年7月29日星期五 UTC+8上午12:19:20，楓之舞写道：
当时考虑 ngx.worker.id() 获得是系统分配的进程ID。每次会变，不好在配置文件里绑定。
另外，如果绑定的话，一旦对应的worker异常退出。任务就不会再处理。比较麻烦。

其实我觉得用nginx中的定时任务会隐藏太多复杂度。倒不如直接用另一个程序定时调用nginx http 接口，获取需要的值 :)

2016-07-28 17:22 GMT+08:00 <soae...@gmail.com>:
恩 是的如果用 ngx.worker.id() 的话就不用枷锁了，况且在init_worker_by*中好似不能使用  lua-resty-lock 的

在 2016年7月28日星期四 UTC+8下午2:05:46，WenMing写道：
你用 ngx.worker.id() 的话，就不用锁了。直接绑定在某个 NGINX worker 上面运行。

在 2016年7月27日 下午11:00，.楓之舞 <chang...@gmail.com>写道：
我在 init_work_by_lua 中这样做的：
比如，任务每隔60秒执行一次：

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

handler = function (premature)

    -- do some routine job in Lua just like a cron job

    if premature then

        return

    end

    local success, err, forcible = tags:add("xxxx", ngx.now(), 60)
    if  success then
        -- 锁抢到了。执行任务
        ...

    else

       -- 锁没有抢到。其他程序已经处理了

    end 


   local ok, err = ngx.timer.at(ceil(delay/10), handler)

    if not ok then

        ngx.log(ngx.ERR, "failed to create the timer: ", err)

        return

    end

end

-- 第一次添加一个延时. 延时时间: math.random(8, 32).  避免一堆worker同时抢锁

local ok, err = ngx.timer.at(delay + math.random(8, 32), handler)

if not ok then

    ngx.log(ngx.ERR, "failed to create the timer: ", err)

    return

end

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



2016-07-27 16:48 GMT+08:00 YuanSheng Wang <yuan...@openresty.org>:


2016-07-27 15:51 GMT+08:00 <soae...@gmail.com>:
恩在init_work_by_lua中根据ngx.worker.id() 来决定最终执行定时器的进程是谁。这个问题解决了，哈哈谢谢，不过当nginx的某个worker进程被kill掉以后  nginx master进程会继续fork出新的进程，这个时候还是要判断到底kill掉的进程是否是启动定时器的进程。 还在解决中

新 fork 出来的进程，ngx.worker.id() 返回结果是一致的。所以比较容易完成某个 worker 工作的需求。

 


在 2016年7月27日星期三 UTC+8上午11:32:53，WenMing写道：
你可以使用  ngx.worker.id() 来试试。

在 2016年7月27日 上午11:03， <soae...@gmail.com>写道：
Hello,

       现在遇到一个问题就是我想创建一个定时器，然后定时的去更新ngx.shared.DICT中的值，我担心的是会不会我创建了一个定时器后 所有的work process都会用这个定时器去更新ngx.shared.DICT)里面的值，我的主要目的是想只有一个进程去更新，而不是所有的进程都去用这个定时器。不知道怎么做这个

--

--



--

YuanSheng Wang
---------------------------------------
OpenResty lover ^_^

--

--

--

crasyangel.lhy

那个变量名应该是ngx_worker，全局变量

在 2016年7月29日星期五 UTC+8下午6:32:33，高岩写道：
不是，worker.id取的是worker_num，而worker_number是spwan_worker传进来的i，而不是slot

在 2016年7月29日星期五 UTC+8上午12:19:20，楓之舞写道：
当时考虑 ngx.worker.id() 获得是系统分配的进程ID。每次会变，不好在配置文件里绑定。
另外，如果绑定的话，一旦对应的worker异常退出。任务就不会再处理。比较麻烦。

其实我觉得用nginx中的定时任务会隐藏太多复杂度。倒不如直接用另一个程序定时调用nginx http 接口，获取需要的值 :)

2016-07-28 17:22 GMT+08:00 <soae...@gmail.com>:
恩 是的如果用 ngx.worker.id() 的话就不用枷锁了，况且在init_worker_by*中好似不能使用  lua-resty-lock 的

在 2016年7月28日星期四 UTC+8下午2:05:46，WenMing写道：
你用 ngx.worker.id() 的话，就不用锁了。直接绑定在某个 NGINX worker 上面运行。

在 2016年7月27日 下午11:00，.楓之舞 <chang...@gmail.com>写道：
我在 init_work_by_lua 中这样做的：
比如，任务每隔60秒执行一次：

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

handler = function (premature)

    -- do some routine job in Lua just like a cron job

    if premature then

        return

    end

    local success, err, forcible = tags:add("xxxx", ngx.now(), 60)
    if  success then
        -- 锁抢到了。执行任务
        ...

    else

       -- 锁没有抢到。其他程序已经处理了

    end 


   local ok, err = ngx.timer.at(ceil(delay/10), handler)

    if not ok then

        ngx.log(ngx.ERR, "failed to create the timer: ", err)

        return

    end

end

-- 第一次添加一个延时. 延时时间: math.random(8, 32).  避免一堆worker同时抢锁

local ok, err = ngx.timer.at(delay + math.random(8, 32), handler)

if not ok then

    ngx.log(ngx.ERR, "failed to create the timer: ", err)

    return

end

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



2016-07-27 16:48 GMT+08:00 YuanSheng Wang <yuan...@openresty.org>:


2016-07-27 15:51 GMT+08:00 <soae...@gmail.com>:
恩在init_work_by_lua中根据ngx.worker.id() 来决定最终执行定时器的进程是谁。这个问题解决了，哈哈谢谢，不过当nginx的某个worker进程被kill掉以后  nginx master进程会继续fork出新的进程，这个时候还是要判断到底kill掉的进程是否是启动定时器的进程。 还在解决中

新 fork 出来的进程，ngx.worker.id() 返回结果是一致的。所以比较容易完成某个 worker 工作的需求。

 


在 2016年7月27日星期三 UTC+8上午11:32:53，WenMing写道：
你可以使用  ngx.worker.id() 来试试。

在 2016年7月27日 上午11:03， <soae...@gmail.com>写道：
Hello,

       现在遇到一个问题就是我想创建一个定时器，然后定时的去更新ngx.shared.DICT中的值，我担心的是会不会我创建了一个定时器后 所有的work process都会用这个定时器去更新ngx.shared.DICT)里面的值，我的主要目的是想只有一个进程去更新，而不是所有的进程都去用这个定时器。不知道怎么做这个

--

--



--

YuanSheng Wang
---------------------------------------
OpenResty lover ^_^

--

--

--

yuansheng



2016-07-29 0:19 GMT+08:00 .楓之舞 <chang...@gmail.com>:
当时考虑 ngx.worker.id() 获得是系统分配的进程ID。每次会变，不好在配置文件里绑定。

注意 ngx.worker.id() 和 ngx.worker.pid() 是不一样的。
前者获取的是 nginx 内部分配的顺序 ID，后者才是进程 ID。

 

另外，如果绑定的话，一旦对应的worker异常退出。任务就不会再处理。比较麻烦。

其实我觉得用nginx中的定时任务会隐藏太多复杂度。倒不如直接用另一个程序定时调用nginx http 接口，获取需要的值 :)

2016-07-28 17:22 GMT+08:00 <soa...@gmail.com>:
恩 是的如果用 ngx.worker.id() 的话就不用枷锁了，况且在init_worker_by*中好似不能使用  lua-resty-lock 的

在 2016年7月28日星期四 UTC+8下午2:05:46，WenMing写道：
你用 ngx.worker.id() 的话，就不用锁了。直接绑定在某个 NGINX worker 上面运行。

在 2016年7月27日 下午11:00，.楓之舞 <chang...@gmail.com>写道：
我在 init_work_by_lua 中这样做的：
比如，任务每隔60秒执行一次：

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

handler = function (premature)

    -- do some routine job in Lua just like a cron job

    if premature then

        return

    end

    local success, err, forcible = tags:add("xxxx", ngx.now(), 60)
    if  success then
        -- 锁抢到了。执行任务
        ...

    else

       -- 锁没有抢到。其他程序已经处理了

    end 


   local ok, err = ngx.timer.at(ceil(delay/10), handler)

    if not ok then

        ngx.log(ngx.ERR, "failed to create the timer: ", err)

        return

    end

end

-- 第一次添加一个延时. 延时时间: math.random(8, 32).  避免一堆worker同时抢锁

local ok, err = ngx.timer.at(delay + math.random(8, 32), handler)

if not ok then

    ngx.log(ngx.ERR, "failed to create the timer: ", err)

    return

end

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



2016-07-27 16:48 GMT+08:00 YuanSheng Wang <yuan...@openresty.org>:


2016-07-27 15:51 GMT+08:00 <soae...@gmail.com>:
恩在init_work_by_lua中根据ngx.worker.id() 来决定最终执行定时器的进程是谁。这个问题解决了，哈哈谢谢，不过当nginx的某个worker进程被kill掉以后  nginx master进程会继续fork出新的进程，这个时候还是要判断到底kill掉的进程是否是启动定时器的进程。 还在解决中

新 fork 出来的进程，ngx.worker.id() 返回结果是一致的。所以比较容易完成某个 worker 工作的需求。

 


在 2016年7月27日星期三 UTC+8上午11:32:53，WenMing写道：
你可以使用  ngx.worker.id() 来试试。

在 2016年7月27日 上午11:03， <soae...@gmail.com>写道：
Hello,

       现在遇到一个问题就是我想创建一个定时器，然后定时的去更新ngx.shared.DICT中的值，我担心的是会不会我创建了一个定时器后 所有的work process都会用这个定时器去更新ngx.shared.DICT)里面的值，我的主要目的是想只有一个进程去更新，而不是所有的进程都去用这个定时器。不知道怎么做这个

--

--



--

YuanSheng Wang
---------------------------------------
OpenResty lover ^_^

--

--

--

--



--

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

changfeng29

哦, 这样. 之前没注意到 ngx.worker.id 这个函数. 多谢 :)

2016-07-30 12:33 GMT+08:00 YuanSheng Wang <yuan...@openresty.org>:


2016-07-29 0:19 GMT+08:00 .楓之舞 <chang...@gmail.com>:
当时考虑 ngx.worker.id() 获得是系统分配的进程ID。每次会变，不好在配置文件里绑定。

注意 ngx.worker.id() 和 ngx.worker.pid() 是不一样的。
前者获取的是 nginx 内部分配的顺序 ID，后者才是进程 ID。

 

另外，如果绑定的话，一旦对应的worker异常退出。任务就不会再处理。比较麻烦。

其实我觉得用nginx中的定时任务会隐藏太多复杂度。倒不如直接用另一个程序定时调用nginx http 接口，获取需要的值 :)

2016-07-28 17:22 GMT+08:00 <soa...@gmail.com>:
恩 是的如果用 ngx.worker.id() 的话就不用枷锁了，况且在init_worker_by*中好似不能使用  lua-resty-lock 的

在 2016年7月28日星期四 UTC+8下午2:05:46，WenMing写道：
你用 ngx.worker.id() 的话，就不用锁了。直接绑定在某个 NGINX worker 上面运行。

在 2016年7月27日 下午11:00，.楓之舞 <chang...@gmail.com>写道：
我在 init_work_by_lua 中这样做的：
比如，任务每隔60秒执行一次：

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

handler = function (premature)

    -- do some routine job in Lua just like a cron job

    if premature then

        return

    end

    local success, err, forcible = tags:add("xxxx", ngx.now(), 60)
    if  success then
        -- 锁抢到了。执行任务
        ...

    else

       -- 锁没有抢到。其他程序已经处理了

    end 


   local ok, err = ngx.timer.at(ceil(delay/10), handler)

    if not ok then

        ngx.log(ngx.ERR, "failed to create the timer: ", err)

        return

    end

end

-- 第一次添加一个延时. 延时时间: math.random(8, 32).  避免一堆worker同时抢锁

local ok, err = ngx.timer.at(delay + math.random(8, 32), handler)

if not ok then

    ngx.log(ngx.ERR, "failed to create the timer: ", err)

    return

end

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



2016-07-27 16:48 GMT+08:00 YuanSheng Wang <yuan...@openresty.org>:


2016-07-27 15:51 GMT+08:00 <soae...@gmail.com>:
恩在init_work_by_lua中根据ngx.worker.id() 来决定最终执行定时器的进程是谁。这个问题解决了，哈哈谢谢，不过当nginx的某个worker进程被kill掉以后  nginx master进程会继续fork出新的进程，这个时候还是要判断到底kill掉的进程是否是启动定时器的进程。 还在解决中

新 fork 出来的进程，ngx.worker.id() 返回结果是一致的。所以比较容易完成某个 worker 工作的需求。

 


在 2016年7月27日星期三 UTC+8上午11:32:53，WenMing写道：
你可以使用  ngx.worker.id() 来试试。

在 2016年7月27日 上午11:03， <soae...@gmail.com>写道：
Hello,

       现在遇到一个问题就是我想创建一个定时器，然后定时的去更新ngx.shared.DICT中的值，我担心的是会不会我创建了一个定时器后 所有的work process都会用这个定时器去更新ngx.shared.DICT)里面的值，我的主要目的是想只有一个进程去更新，而不是所有的进程都去用这个定时器。不知道怎么做这个

--

--



--

YuanSheng Wang
---------------------------------------
OpenResty lover ^_^

--

--

--

--



--

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

--

ssdrliu

手动点赞~

在 2016年7月28日星期四 UTC+8上午9:02:52，Guanglin Lv写道：

我也有类似的场景，我的做法是：

使用共享内存的add方法来抢锁，谁抢到了就由哪个worker来做（假设A抢到），没抢到的worker各起一个守护定时器（假设B、C、D），定时监测worker A是否在做事；

当发现worker A几个周期都没有在工作的时候，比如：worker A异常crash、或被阻塞了等。则B、C、C再次执行抢锁。


在 2016年7月27日星期三 UTC+8下午3:51:56，soae...@gmail.com写道：
恩在init_work_by_lua中根据ngx.worker.id() 来决定最终执行定时器的进程是谁。这个问题解决了，哈哈谢谢，不过当nginx的某个worker进程被kill掉以后  nginx master进程会继续fork出新的进程，这个时候还是要判断到底kill掉的进程是否是启动定时器的进程。 还在解决中

在 2016年7月27日星期三 UTC+8上午11:32:53，WenMing写道：
你可以使用  ngx.worker.id() 来试试。

在 2016年7月27日 上午11:03， <soae...@gmail.com>写道：
Hello,

       现在遇到一个问题就是我想创建一个定时器，然后定时的去更新ngx.shared.DICT中的值，我担心的是会不会我创建了一个定时器后 所有的work process都会用这个定时器去更新ngx.shared.DICT)里面的值，我的主要目的是想只有一个进程去更新，而不是所有的进程都去用这个定时器。不知道怎么做这个

--

382482175

哥们，你是怎么抢锁的，。。。不用ngx.worker.id() (tengine里面用不了）

在 2016年7月27日星期三 UTC-7下午6:02:52，Guanglin Lv写道：

我也有类似的场景，我的做法是：

使用共享内存的add方法来抢锁，谁抢到了就由哪个worker来做（假设A抢到），没抢到的worker各起一个守护定时器（假设B、C、D），定时监测worker A是否在做事；

当发现worker A几个周期都没有在工作的时候，比如：worker A异常crash、或被阻塞了等。则B、C、C再次执行抢锁。


在 2016年7月27日星期三 UTC+8下午3:51:56，soae...@gmail.com写道：
恩在init_work_by_lua中根据ngx.worker.id() 来决定最终执行定时器的进程是谁。这个问题解决了，哈哈谢谢，不过当nginx的某个worker进程被kill掉以后  nginx master进程会继续fork出新的进程，这个时候还是要判断到底kill掉的进程是否是启动定时器的进程。 还在解决中

在 2016年7月27日星期三 UTC+8上午11:32:53，WenMing写道：
你可以使用  ngx.worker.id() 来试试。

在 2016年7月27日 上午11:03， <soae...@gmail.com>写道：
Hello,

       现在遇到一个问题就是我想创建一个定时器，然后定时的去更新ngx.shared.DICT中的值，我担心的是会不会我创建了一个定时器后 所有的work process都会用这个定时器去更新ngx.shared.DICT)里面的值，我的主要目的是想只有一个进程去更新，而不是所有的进程都去用这个定时器。不知道怎么做这个

--

moonbingbing

你有用到 Tengine 的什么特性吗？它带的 ngx lua 版本比较旧

在 2016年8月8日 下午6:29，wwaz wwaz <3824...@qq.com>写道：
哥们，你是怎么抢锁的，。。。不用ngx.worker.id() (tengine里面用不了）

在 2016年7月27日星期三 UTC-7下午6:02:52，Guanglin Lv写道：

我也有类似的场景，我的做法是：

使用共享内存的add方法来抢锁，谁抢到了就由哪个worker来做（假设A抢到），没抢到的worker各起一个守护定时器（假设B、C、D），定时监测worker A是否在做事；

当发现worker A几个周期都没有在工作的时候，比如：worker A异常crash、或被阻塞了等。则B、C、C再次执行抢锁。


在 2016年7月27日星期三 UTC+8下午3:51:56，soae...@gmail.com写道：
恩在init_work_by_lua中根据ngx.worker.id() 来决定最终执行定时器的进程是谁。这个问题解决了，哈哈谢谢，不过当nginx的某个worker进程被kill掉以后  nginx master进程会继续fork出新的进程，这个时候还是要判断到底kill掉的进程是否是启动定时器的进程。 还在解决中

在 2016年7月27日星期三 UTC+8上午11:32:53，WenMing写道：
你可以使用  ngx.worker.id() 来试试。

在 2016年7月27日 上午11:03， <soae...@gmail.com>写道：
Hello,

       现在遇到一个问题就是我想创建一个定时器，然后定时的去更新ngx.shared.DICT中的值，我担心的是会不会我创建了一个定时器后 所有的work process都会用这个定时器去更新ngx.shared.DICT)里面的值，我的主要目的是想只有一个进程去更新，而不是所有的进程都去用这个定时器。不知道怎么做这个

--

--

382482175

温民哥好：）
因为公司用的是tengine＋ngx_lua，所以没法切到OR。。现在tengine版本是2.1.2，用不了ngx.worker.id()来bind timer。
有没有什么办法呢？：）

在 2016年8月8日星期一 UTC-7下午7:06:31，WenMing写道：
你有用到 Tengine 的什么特性吗？它带的 ngx lua 版本比较旧

在 2016年8月8日 下午6:29，wwaz wwaz <3824...@qq.com>写道：
哥们，你是怎么抢锁的，。。。不用ngx.worker.id() (tengine里面用不了）

在 2016年7月27日星期三 UTC-7下午6:02:52，Guanglin Lv写道：

我也有类似的场景，我的做法是：

使用共享内存的add方法来抢锁，谁抢到了就由哪个worker来做（假设A抢到），没抢到的worker各起一个守护定时器（假设B、C、D），定时监测worker A是否在做事；

当发现worker A几个周期都没有在工作的时候，比如：worker A异常crash、或被阻塞了等。则B、C、C再次执行抢锁。


在 2016年7月27日星期三 UTC+8下午3:51:56，soae...@gmail.com写道：
恩在init_work_by_lua中根据ngx.worker.id() 来决定最终执行定时器的进程是谁。这个问题解决了，哈哈谢谢，不过当nginx的某个worker进程被kill掉以后  nginx master进程会继续fork出新的进程，这个时候还是要判断到底kill掉的进程是否是启动定时器的进程。 还在解决中

在 2016年7月27日星期三 UTC+8上午11:32:53，WenMing写道：
你可以使用  ngx.worker.id() 来试试。

在 2016年7月27日 上午11:03， <soae...@gmail.com>写道：
Hello,

       现在遇到一个问题就是我想创建一个定时器，然后定时的去更新ngx.shared.DICT中的值，我担心的是会不会我创建了一个定时器后 所有的work process都会用这个定时器去更新ngx.shared.DICT)里面的值，我的主要目的是想只有一个进程去更新，而不是所有的进程都去用这个定时器。不知道怎么做这个

--

--