一个socket对象，可以同时保持多个连接？

ms2008vip · 2015-12-25T23:04:48+00:00

Hello! 2015-12-25 2:50 GMT-08:00 Ming: > > 看春哥2016年的计划，里面提到&#x6709...

一个socket对象，可以同时保持多个连接？

ms2008vip

测试用例

./resty -e '
    local sock = ngx.socket.tcp()
    ngx.say(sock:connect("127.0.0.1", 80))
    ngx.say(sock:setkeepalive())


    ngx.say(sock:connect("127.0.0.1", 8989))
    ngx.say(sock:setkeepalive())
    ngx.sleep(60)
'

但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

ms2008vip

我的疑问：

1. openresty 中的 tcpsocket:connect 难道会产生新的 socket 对象？

2. 连接池中的连接的本质是？socket 对象，还是仅仅就是一个五元组的状态
3. 如果这里的两个连接都是可用的，为什么通过thread却要创建出不同的socket对象出来？

在 2015年12月25日星期五 UTC+8下午11:04:48，ms2008写道：

测试用例

./resty -e ' local sock = ngx.socket.tcp() ngx.say(sock:connect("127.0.0.1", 80)) ngx.say(sock:setkeepalive()) ngx.say(sock:connect("127.0.0.1", 8989)) ngx.say(sock:setkeepalive()) ngx.sleep(60) '

但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

doujiang24

Hello

在 2015年12月25日下午11:04，ms2008 <ms20...@gmail.com>写道：

测试用例

./resty -e ' local sock = ngx.socket.tcp() ngx.say(sock:connect("127.0.0.1", 80)) ngx.say(sock:setkeepalive())

setkeepalive 已经把当前的连接放入连接池了，也就是说 sock 与这个连接已经没有任何关系了

在这之后，你再进行 sock:send, sock:read 之类的操作都会报错了

连接池其实是在一个看不到的地方，并没有暴露一个链接池的对象出来

只有 setkeepalive 把当前连接入池，以及 connect 优先从连接池选取

ngx.say(sock:connect("127.0.0.1", 8989)) ngx.say(sock:setkeepalive()) ngx.sleep(60) '

但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

--

ms2008vip

恩，我的意思是第二次的 connect 还是会使用第一行那个sock 对象吗？

如果就是那个sock，为什么我用ss观察到的是两个sock对象，另外一个是谁创建的？

还有就是可以看到这时候 80、8989 都是出于连接的状态，那就是说这两个连接都是有效的喽？

在 2015年12月25日星期五 UTC+8下午11:28:05，doujiang写道：

Hello

在 2015年12月25日下午11:04，ms2008 <ms20...@gmail.com>写道：
测试用例

./resty -e ' local sock = ngx.socket.tcp() ngx.say(sock:connect("127.0.0.1", 80)) ngx.say(sock:setkeepalive())

setkeepalive 已经把当前的连接放入连接池了，也就是说 sock 与这个连接已经没有任何关系了
在这之后，你再进行 sock:send, sock:read 之类的操作都会报错了

连接池其实是在一个看不到的地方，并没有暴露一个链接池的对象出来
只有 setkeepalive 把当前连接入池，以及 connect 优先从连接池选取

ngx.say(sock:connect("127.0.0.1", 8989)) ngx.say(sock:setkeepalive()) ngx.sleep(60) '

但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

--

doujiang24

Hello

在 2015年12月25日下午11:36，ms2008 <ms20...@gmail.com>写道：

恩，我的意思是第二次的 connect 还是会使用第一行那个sock 对象吗？

`sock` 这个还是原来那个

不过，你理解的 sock 可能是 kernel 态的 sock（也就是我上面提到的连接）

你可以把暴露在 Lua 里的 `sock` 理解为一个更上层的连接，封装了一层同步非阻塞的 API

你看到的两个连接，也就是 `connection`，可以理解为 kernel 概念里的 sock，他只是这个 `sock` 内的一个属性，一个被 API 操作的对象

这么说，不知道清楚了不？

如果就是那个sock，为什么我用ss观察到的是两个sock对象，另外一个是谁创建的？

都是你

还有就是可以看到这时候 80、8989 都是出于连接的状态，那就是说这两个连接都是有效的喽？

都是真实有效的连接，只是你现在没有办法操作已经入池了的连接

这个连接已经交给连接池托管了

在 2015年12月25日星期五 UTC+8下午11:28:05，doujiang写道：
Hello

在 2015年12月25日下午11:04，ms2008 <ms20...@gmail.com>写道：
测试用例

./resty -e ' local sock = ngx.socket.tcp() ngx.say(sock:connect("127.0.0.1", 80)) ngx.say(sock:setkeepalive())

setkeepalive 已经把当前的连接放入连接池了，也就是说 sock 与这个连接已经没有任何关系了
在这之后，你再进行 sock:send, sock:read 之类的操作都会报错了

连接池其实是在一个看不到的地方，并没有暴露一个链接池的对象出来
只有 setkeepalive 把当前连接入池，以及 connect 优先从连接池选取

ngx.say(sock:connect("127.0.0.1", 8989)) ngx.say(sock:setkeepalive()) ngx.sleep(60) '

但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

--

--

doujiang24

Hello

在 2015年12月25日下午11:47，DeJiang Zhu <douj...@gmail.com>写道：

Hello

在 2015年12月25日下午11:36，ms2008 <ms20...@gmail.com>写道：
恩，我的意思是第二次的 connect 还是会使用第一行那个sock 对象吗？

`sock` 这个还是原来那个
不过，你理解的 sock 可能是 kernel 态的 sock（也就是我上面提到的连接）

你可以把暴露在 Lua 里的 `sock` 理解为一个更上层的连接，封装了一层同步非阻塞的 API

抱歉，手误

你可以把暴露在 Lua 里的 `sock` 理解为一个 *更上层* 的概念，一个封装了一套同步非阻塞的 API 的对象

你看到的两个连接，也就是 `connection`，可以理解为 kernel 概念里的 sock，他只是这个 `sock` 内的一个属性，一个被 API 操作的对象
这么说，不知道清楚了不？

如果就是那个sock，为什么我用ss观察到的是两个sock对象，另外一个是谁创建的？

都是你

还有就是可以看到这时候 80、8989 都是出于连接的状态，那就是说这两个连接都是有效的喽？

都是真实有效的连接，只是你现在没有办法操作已经入池了的连接
这个连接已经交给连接池托管了

在 2015年12月25日星期五 UTC+8下午11:28:05，doujiang写道：
Hello

在 2015年12月25日下午11:04，ms2008 <ms20...@gmail.com>写道：
测试用例

./resty -e ' local sock = ngx.socket.tcp() ngx.say(sock:connect("127.0.0.1", 80)) ngx.say(sock:setkeepalive())

setkeepalive 已经把当前的连接放入连接池了，也就是说 sock 与这个连接已经没有任何关系了
在这之后，你再进行 sock:send, sock:read 之类的操作都会报错了

连接池其实是在一个看不到的地方，并没有暴露一个链接池的对象出来
只有 setkeepalive 把当前连接入池，以及 connect 优先从连接池选取

ngx.say(sock:connect("127.0.0.1", 8989)) ngx.say(sock:setkeepalive()) ngx.sleep(60) '

但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

--

--

ms2008vip

ok，也就是说在 Lua 层面上这个 ‘sock‘ 可以拥有多个属性(connection) ？

但是在 ngx.thread 中，我们却不能共用一个 socket 对象，会报 sock busy，这个又该如何解释(不能拥有多个‘属性’)？

在 2015年12月25日星期五 UTC+8下午11:47:44，doujiang写道：

Hello

在 2015年12月25日下午11:36，ms2008 <ms20...@gmail.com>写道：
恩，我的意思是第二次的 connect 还是会使用第一行那个sock 对象吗？

`sock` 这个还是原来那个
不过，你理解的 sock 可能是 kernel 态的 sock（也就是我上面提到的连接）

你可以把暴露在 Lua 里的 `sock` 理解为一个更上层的连接，封装了一层同步非阻塞的 API
你看到的两个连接，也就是 `connection`，可以理解为 kernel 概念里的 sock，他只是这个 `sock` 内的一个属性，一个被 API 操作的对象
这么说，不知道清楚了不？

如果就是那个sock，为什么我用ss观察到的是两个sock对象，另外一个是谁创建的？

都是你

还有就是可以看到这时候 80、8989 都是出于连接的状态，那就是说这两个连接都是有效的喽？

都是真实有效的连接，只是你现在没有办法操作已经入池了的连接
这个连接已经交给连接池托管了

在 2015年12月25日星期五 UTC+8下午11:28:05，doujiang写道：
Hello

在 2015年12月25日下午11:04，ms2008 <ms20...@gmail.com>写道：
测试用例

./resty -e ' local sock = ngx.socket.tcp() ngx.say(sock:connect("127.0.0.1", 80)) ngx.say(sock:setkeepalive())

setkeepalive 已经把当前的连接放入连接池了，也就是说 sock 与这个连接已经没有任何关系了
在这之后，你再进行 sock:send, sock:read 之类的操作都会报错了

连接池其实是在一个看不到的地方，并没有暴露一个链接池的对象出来
只有 setkeepalive 把当前连接入池，以及 connect 优先从连接池选取

ngx.say(sock:connect("127.0.0.1", 8989)) ngx.say(sock:setkeepalive()) ngx.sleep(60) '

但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

--

--

doujiang24

Hello

在 2015年12月26日上午12:12，ms2008 <ms20...@gmail.com>写道：

ok，也就是说在 Lua 层面上这个 ‘sock‘ 可以拥有多个属性(connection) ？

一个 `sock` 同时只能拥有一个 `connection`

但是在 ngx.thread 中，我们却不能共用一个 socket 对象，会报 sock busy，这个又该如何解释(不能拥有多个‘属性’)？

一个连接 `connection` 不能被两个 thread 同时读，或者同时写（读写全双工是支持的了，也即：一个 thread 读，一个 thread 写）

其实也就是一个 `sock` 不能够被两个 thread 同时读，或者同时写了

在 2015年12月25日星期五 UTC+8下午11:47:44，doujiang写道：
Hello

在 2015年12月25日下午11:36，ms2008 <ms20...@gmail.com>写道：
恩，我的意思是第二次的 connect 还是会使用第一行那个sock 对象吗？

`sock` 这个还是原来那个
不过，你理解的 sock 可能是 kernel 态的 sock（也就是我上面提到的连接）

你可以把暴露在 Lua 里的 `sock` 理解为一个更上层的连接，封装了一层同步非阻塞的 API
你看到的两个连接，也就是 `connection`，可以理解为 kernel 概念里的 sock，他只是这个 `sock` 内的一个属性，一个被 API 操作的对象
这么说，不知道清楚了不？

如果就是那个sock，为什么我用ss观察到的是两个sock对象，另外一个是谁创建的？

都是你

还有就是可以看到这时候 80、8989 都是出于连接的状态，那就是说这两个连接都是有效的喽？

都是真实有效的连接，只是你现在没有办法操作已经入池了的连接
这个连接已经交给连接池托管了

在 2015年12月25日星期五 UTC+8下午11:28:05，doujiang写道：
Hello

在 2015年12月25日下午11:04，ms2008 <ms20...@gmail.com>写道：
测试用例

./resty -e ' local sock = ngx.socket.tcp() ngx.say(sock:connect("127.0.0.1", 80)) ngx.say(sock:setkeepalive())

setkeepalive 已经把当前的连接放入连接池了，也就是说 sock 与这个连接已经没有任何关系了
在这之后，你再进行 sock:send, sock:read 之类的操作都会报错了

连接池其实是在一个看不到的地方，并没有暴露一个链接池的对象出来
只有 setkeepalive 把当前连接入池，以及 connect 优先从连接池选取

ngx.say(sock:connect("127.0.0.1", 8989)) ngx.say(sock:setkeepalive()) ngx.sleep(60) '

但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

--

--

--

ms2008vip

恩，谢谢你，理解了。

还有就是我这个用例会不会有潜在的问题，即：我先用一个 socket 连接了 80 端口，然后把它放入到连接池

紧接着我又继续用这个 socket 连接 8989 端口，但是假如此时，有其他的请求需要取出连接池的 80 连接，

而我却正在用这个 socket 建立 8989 连接，那么这个时候，会不会有同时读的问题？也就是连接池中的连接是否安全？

在 2015年12月26日星期六 UTC+8上午9:44:08，doujiang写道：

Hello

在 2015年12月26日上午12:12，ms2008 <ms20...@gmail.com>写道：
ok，也就是说在 Lua 层面上这个 ‘sock‘ 可以拥有多个属性(connection) ？

一个 `sock` 同时只能拥有一个 `connection`

但是在 ngx.thread 中，我们却不能共用一个 socket 对象，会报 sock busy，这个又该如何解释(不能拥有多个‘属性’)？

一个连接 `connection` 不能被两个 thread 同时读，或者同时写（读写全双工是支持的了，也即：一个 thread 读，一个 thread 写）
其实也就是一个 `sock` 不能够被两个 thread 同时读，或者同时写了

在 2015年12月25日星期五 UTC+8下午11:47:44，doujiang写道：
Hello

在 2015年12月25日下午11:36，ms2008 <ms20...@gmail.com>写道：
恩，我的意思是第二次的 connect 还是会使用第一行那个sock 对象吗？

`sock` 这个还是原来那个
不过，你理解的 sock 可能是 kernel 态的 sock（也就是我上面提到的连接）

你可以把暴露在 Lua 里的 `sock` 理解为一个更上层的连接，封装了一层同步非阻塞的 API
你看到的两个连接，也就是 `connection`，可以理解为 kernel 概念里的 sock，他只是这个 `sock` 内的一个属性，一个被 API 操作的对象
这么说，不知道清楚了不？

如果就是那个sock，为什么我用ss观察到的是两个sock对象，另外一个是谁创建的？

都是你

还有就是可以看到这时候 80、8989 都是出于连接的状态，那就是说这两个连接都是有效的喽？

都是真实有效的连接，只是你现在没有办法操作已经入池了的连接
这个连接已经交给连接池托管了

在 2015年12月25日星期五 UTC+8下午11:28:05，doujiang写道：
Hello

在 2015年12月25日下午11:04，ms2008 <ms20...@gmail.com>写道：
测试用例

./resty -e ' local sock = ngx.socket.tcp() ngx.say(sock:connect("127.0.0.1", 80)) ngx.say(sock:setkeepalive())

setkeepalive 已经把当前的连接放入连接池了，也就是说 sock 与这个连接已经没有任何关系了
在这之后，你再进行 sock:send, sock:read 之类的操作都会报错了

连接池其实是在一个看不到的地方，并没有暴露一个链接池的对象出来
只有 setkeepalive 把当前连接入池，以及 connect 优先从连接池选取

ngx.say(sock:connect("127.0.0.1", 8989)) ngx.say(sock:setkeepalive()) ngx.sleep(60) '

但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

--

--

--

stupidlw

Hi:

> 恩，谢谢你，理解了。
> 还有就是我这个用例会不会有潜在的问题，即：我先用一个 socket 连接了 80 端口，然后把它放入到连接池
> 
> 紧接着我又继续用这个 socket 连接 8989 端口，但是假如此时，有其他的请求需要取出连接池的 80 连接，

你可以去读一下 ngx_lua-x.x.x/src/ngx_http_lua_socket_tcp.c里面的代码，ngx_http_lua_socket_tcp_connect实现了ngx.socket.connect，ngx_http_lua_socket_tcp_setkeepalive实现了ngx.socket.setkeepalive。如果我对这里面的代码没有理解错的话，connect过程是先根据连接的IP和PORT选择连接池，从连接池中拿出一个连接（如果连接池为空，再去建立新连接）。所以，如果你在lua代码中connect的ip和port不一样的话，选择的内建连接池是不一样的。

> 而我却正在用这个 socket 建立 8989 连接，那么这个时候，会不会有同时读的问题？也就是连接池中的连接是否安全？
> 

nginx的worker进程是单线程，所以不会出现你所说的同时读写的并发安全的问题

stupidlw

测试用例

./resty -e ‘ 1： local sock = ngx.socket.tcp() 2： ngx.say(sock:connect("127.0.0.1", 80)) 3： ngx.say(sock:setkeepalive()) 4： ngx.say(sock:connect("127.0.0.1", 8989)) 5： ngx.say(sock:setkeepalive()) 6： ngx.sleep(60) '
但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

从这个例子中也可以看出来，connect操作是根据（ip，port）这个元组选择对应的sock，如果（ip，port）和以前的sock不一致，会新建一个sock。你可以去试试，如果你在上面第四行中继续去connect（127.0.0.1, 80）的话，就只会有一个socket存在（复用了第三行setkeepalive放进连接池的sock）。当然如果要严格的说的话，connect先会去尝试从第三个可选参数option table里去拿连接，如果没拿到，才会有上述流程。

ms2008vip

嗯？这个理解貌似和 @doujiang 的回复有些出入？如果 connect 会有创建新 sock 的行为，那么我在 ngx.thread 中

共享一个 sock 对象，在不同的 ‘线程’ 中，connect 不同的元组，为什么还会有 sock busy 的错误？显然它并不会

创建新 sock 出来，或许正如 @doujiang 所言，此 ‘socket’ 非彼 ‘sock’？

在 2015年12月26日星期六 UTC+8下午2:27:08，liuwei写道：

测试用例

./resty -e ‘ 1： local sock = ngx.socket.tcp() 2： ngx.say(sock:connect("127.0.0.1", 80)) 3： ngx.say(sock:setkeepalive()) 4： ngx.say(sock:connect("127.0.0.1", 8989)) 5： ngx.say(sock:setkeepalive()) 6： ngx.sleep(60) '
但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

从这个例子中也可以看出来，connect操作是根据（ip，port）这个元组选择对应的sock，如果（ip，port）和以前的sock不一致，会新建一个sock。你可以去试试，如果你在上面第四行中继续去connect（127.0.0.1, 80）的话，就只会有一个socket存在（复用了第三行setkeepalive放进连接池的sock）。当然如果要严格的说的话，connect先会去尝试从第三个可选参数option table里去拿连接，如果没拿到，才会有上述流程。

doujiang24

Hello,

在 2015年12月26日下午2:06，ms2008 <ms20...@gmail.com>写道：

恩，谢谢你，理解了。
还有就是我这个用例会不会有潜在的问题，即：我先用一个 socket 连接了 80 端口，然后把它放入到连接池

紧接着我又继续用这个 socket 连接 8989 端口，但是假如此时，有其他的请求需要取出连接池的 80 连接，
而我却正在用这个 socket 建立 8989 连接，那么这个时候，会不会有同时读的问题？

不会，sock:setkeepalive 之后，sock 与连接就没有关系了

也就是连接池中的连接是否安全？

必须是

在 2015年12月26日星期六 UTC+8上午9:44:08，doujiang写道：
Hello

在 2015年12月26日上午12:12，ms2008 <ms20...@gmail.com>写道：
ok，也就是说在 Lua 层面上这个 ‘sock‘ 可以拥有多个属性(connection) ？

一个 `sock` 同时只能拥有一个 `connection`

但是在 ngx.thread 中，我们却不能共用一个 socket 对象，会报 sock busy，这个又该如何解释(不能拥有多个‘属性’)？

一个连接 `connection` 不能被两个 thread 同时读，或者同时写（读写全双工是支持的了，也即：一个 thread 读，一个 thread 写）
其实也就是一个 `sock` 不能够被两个 thread 同时读，或者同时写了

在 2015年12月25日星期五 UTC+8下午11:47:44，doujiang写道：
Hello

在 2015年12月25日下午11:36，ms2008 <ms20...@gmail.com>写道：
恩，我的意思是第二次的 connect 还是会使用第一行那个sock 对象吗？

`sock` 这个还是原来那个
不过，你理解的 sock 可能是 kernel 态的 sock（也就是我上面提到的连接）

你可以把暴露在 Lua 里的 `sock` 理解为一个更上层的连接，封装了一层同步非阻塞的 API
你看到的两个连接，也就是 `connection`，可以理解为 kernel 概念里的 sock，他只是这个 `sock` 内的一个属性，一个被 API 操作的对象
这么说，不知道清楚了不？

如果就是那个sock，为什么我用ss观察到的是两个sock对象，另外一个是谁创建的？

都是你

还有就是可以看到这时候 80、8989 都是出于连接的状态，那就是说这两个连接都是有效的喽？

都是真实有效的连接，只是你现在没有办法操作已经入池了的连接
这个连接已经交给连接池托管了

在 2015年12月25日星期五 UTC+8下午11:28:05，doujiang写道：
Hello

在 2015年12月25日下午11:04，ms2008 <ms20...@gmail.com>写道：
测试用例

./resty -e ' local sock = ngx.socket.tcp() ngx.say(sock:connect("127.0.0.1", 80)) ngx.say(sock:setkeepalive())

setkeepalive 已经把当前的连接放入连接池了，也就是说 sock 与这个连接已经没有任何关系了
在这之后，你再进行 sock:send, sock:read 之类的操作都会报错了

连接池其实是在一个看不到的地方，并没有暴露一个链接池的对象出来
只有 setkeepalive 把当前连接入池，以及 connect 优先从连接池选取

ngx.say(sock:connect("127.0.0.1", 8989)) ngx.say(sock:setkeepalive()) ngx.sleep(60) '

但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

--

--

--

--

doujiang24

Hello

在 2015年12月26日下午2:16，liuwei <stu...@126.com>写道：

> 而我却正在用这个 socket 建立 8989 连接，那么这个时候，会不会有同时读的问题？也就是连接池中的连接是否安全？
>

nginx的worker进程是单线程，所以不会出现你所说的同时读写的并发安全的问题

并不是 worker 为单线程才没有问题哦

实际上同一个 sock 被两个 light thread 同时读（写），是存在并发的，所以会返回 busy 作为保护

--

membphis

./resty -e ‘ 1： local sock = ngx.socket.tcp() 2： ngx.say(sock:connect("127.0.0.1", 80)) 3： ngx.say(sock:setkeepalive()) 4： ngx.say(sock:connect("127.0.0.1", 8989)) 5： ngx.say(sock:setkeepalive()) 6： ngx.sleep(60) '

你的这个示例代码本身就有问题：

第一次连接使用的是 "127.0.0.1", 80

第二次连接使用的是 "127.0.0.1", 8989

如果是连接池复用，首先要保证操作的是同一个池子。而池子名称使用 ip+port 作为标识的。

所以你的这两次操作，实际上操作的是不同池子，自然也就是两个连接了。

2015-12-26 14:56 GMT+08:00 ms2008 <ms20...@gmail.com>:

嗯？这个理解貌似和 @doujiang 的回复有些出入？如果 connect 会有创建新 sock 的行为，那么我在 ngx.thread 中
共享一个 sock 对象，在不同的 ‘线程’ 中，connect 不同的元组，为什么还会有 sock busy 的错误？显然它并不会
创建新 sock 出来，或许正如 @doujiang 所言，此 ‘socket’ 非彼 ‘sock’？

在 2015年12月26日星期六 UTC+8下午2:27:08，liuwei写道：
测试用例

./resty -e ‘ 1： local sock = ngx.socket.tcp() 2： ngx.say(sock:connect("127.0.0.1", 80)) 3： ngx.say(sock:setkeepalive()) 4： ngx.say(sock:connect("127.0.0.1", 8989)) 5： ngx.say(sock:setkeepalive()) 6： ngx.sleep(60) '
但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

从这个例子中也可以看出来，connect操作是根据（ip，port）这个元组选择对应的sock，如果（ip，port）和以前的sock不一致，会新建一个sock。你可以去试试，如果你在上面第四行中继续去connect（127.0.0.1, 80）的话，就只会有一个socket存在（复用了第三行setkeepalive放进连接池的sock）。当然如果要严格的说的话，connect先会去尝试从第三个可选参数option table里去拿连接，如果没拿到，才会有上述流程。

--

Membhis

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

Our Book: OpenResty Best Practices

ms2008vip

恩，我这里只是为了说 openresty 中的 socket 实例化操作，有别于我们传统 socket 编程中的 sock

就像 python 的 socket.socket() 其就是对应于系统 kernel 的一个 socket 句柄，而 openresty 中的

cosocket 实例化操作，是可以对应 kernel 中多个 sock 的，这要取决于你是否将其放入连接池，即 setkeepalive()

就如 @doujiang 所言，'cosocket 一个封装了一套同步非阻塞的 API 的对象' :-)

在 2015年12月28日星期一 UTC+8下午7:00:31，YuanSheng Wang写道：

./resty -e ‘ 1： local sock = ngx.socket.tcp() 2： ngx.say(sock:connect("127.0.0.1", 80)) 3： ngx.say(sock:setkeepalive()) 4： ngx.say(sock:connect("127.0.0.1", 8989)) 5： ngx.say(sock:setkeepalive()) 6： ngx.sleep(60) '

你的这个示例代码本身就有问题：
第一次连接使用的是 "127.0.0.1", 80
第二次连接使用的是 "127.0.0.1", 8989

如果是连接池复用，首先要保证操作的是同一个池子。而池子名称使用 ip+port 作为标识的。
所以你的这两次操作，实际上操作的是不同池子，自然也就是两个连接了。

2015-12-26 14:56 GMT+08:00 ms2008 <ms20...@gmail.com>:
嗯？这个理解貌似和 @doujiang 的回复有些出入？如果 connect 会有创建新 sock 的行为，那么我在 ngx.thread 中
共享一个 sock 对象，在不同的 ‘线程’ 中，connect 不同的元组，为什么还会有 sock busy 的错误？显然它并不会
创建新 sock 出来，或许正如 @doujiang 所言，此 ‘socket’ 非彼 ‘sock’？

在 2015年12月26日星期六 UTC+8下午2:27:08，liuwei写道：
测试用例

./resty -e ‘ 1： local sock = ngx.socket.tcp() 2： ngx.say(sock:connect("127.0.0.1", 80)) 3： ngx.say(sock:setkeepalive()) 4： ngx.say(sock:connect("127.0.0.1", 8989)) 5： ngx.say(sock:setkeepalive()) 6： ngx.sleep(60) '
但是 /proc/2538/fd 下，看到确实是2个 socket，这里的连接池到底该如何理解？

从这个例子中也可以看出来，connect操作是根据（ip，port）这个元组选择对应的sock，如果（ip，port）和以前的sock不一致，会新建一个sock。你可以去试试，如果你在上面第四行中继续去connect（127.0.0.1, 80）的话，就只会有一个socket存在（复用了第三行setkeepalive放进连接池的sock）。当然如果要严格的说的话，connect先会去尝试从第三个可选参数option table里去拿连接，如果没拿到，才会有上述流程。

--

--

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