非阻塞的connect使用方式

最新推荐文章于 2024-07-22 17:46:50 发布
最新推荐文章于 2024-07-22 17:46:50 发布
阅读量2.4k 收藏 6
点赞数
文章标签： c语言 消息队列 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_30192655/article/details/121648036
版权

connect 函数的调用涉及到3次握手，默认connect函数为阻塞连接状态。 通常connect 会阻塞到三次握手的完成和失败，而这个connect阻塞超时时间会依赖于系统，一般为75s到几分钟时间。

一种方式可以通过该系统配置/proc/sys/net/ipv4/tcp_syn_retries，默认为6，可以改为3等。

对于不通过修改配置想要缩短这些超时时间的场景，一般可以采用非阻塞的connect进行连接。

当把一个TCP套接字设置为非阻塞后调用connect，connect会立即返回。

当连接建立成功时，connect返回0；

当connect返回-1失败时，对于非阻塞型，需要判断错误码是否为EINPROGRESS，若为EINPROGRESS，说明tcp正在建立连接，这时我们需要调用select或者poll、epoll等来检查该连接是否建立成功。

处理非阻塞connect的步骤：

第一步:创建socket,返回套接口描述符；

第二步:调用fcntl把套接口描述符设置成非阻塞；

第三步:调用connect开始建立连接；

第四步:判断连接是否成功建立;

若connect返回0,表示连接简称成功。若connect返回-1，且errno为EINPROGRESS，说明tcp正在建立连接，此时可以使用poll等继续处理，当连接建立成功后，会触发out事件，从而唤醒进程，poll返回。

Poll返回值为-1时表示出现错误；

返回值为0表示超时；

返回值大于0时，则说明检测到可读或可写的套接字描述符。但此时还不能判断是否成功，因为

1、当连接建立成功时，套接口描述符变成 可写（连接建立时，写缓冲区空闲，所以可写）

2、当连接建立出错时，套接口描述符变成 既可读又可写（由于有未决的错误，从而可读又可写）

所以此时调用getsockopt来得到套接口上待处理的错误(SO_ERROR)，如果连接建立成功,这个错误值将是0。如果建立连接时遇到错误，则这个值是连接错误所对应的errno值(比如：ECONNREFUSED，ETIMEDOUT等)。

具体实现可以参考redis中 deps\hiredis 下非阻塞connect 实现。

//阻塞方式连接

redisContext *redisConnect(const char *ip, int port) {

redisContext *c;

c = redisContextInit();

c->flags |= REDIS_BLOCK;

redisContextConnectTcp(c,ip,port,NULL);

return c;

}

//阻塞且带超时时间的连接

redisContext *redisConnectWithTimeout(const char *ip, int port, const struct timeval tv) {

redisContext *c;

c = redisContextInit();

c->flags |= REDIS_BLOCK;

redisContextConnectTcp(c,ip,port,&tv);

return c;

}

//非阻塞方式建立连接

redisContext *redisConnectNonBlock(const char *ip, int port) {

redisContext *c;

c = redisContextInit();

c->flags &= ~REDIS_BLOCK;

redisContextConnectTcp(c,ip,port,NULL);

return c;

}

建立连接具体实现:

static int _redisContextConnectTcp(redisContext *c, const char *addr, int port,

const struct timeval *timeout,

const char *source_addr) {

int s, rv, n;

char _port[6]; /* strlen(“65535”); */

struct addrinfo hints, *servinfo, *bservinfo, *p, *b;

int blocking = (c->flags & REDIS_BLOCK);

int reuseaddr = (c->flags & REDIS_REUSEADDR);

int reuses = 0;

long timeout_msec = -1;

servinfo = NULL;

c->connection_type = REDIS_CONN_TCP;

c->tcp.port = port;

if (c->tcp.host != addr) {

if (c->tcp.host)

free(c->tcp.host);

c->tcp.host = strdup(addr);

}

if (timeout) {

if (c->timeout != timeout) {

if (c->timeout == NULL)

c->timeout = malloc(sizeof(struct timeval));

memcpy(c->timeout, timeout, sizeof(struct timeval));

}

} else {

if (c->timeout)

free(c->timeout);

c->timeout = NULL;

}

if (redisContextTimeoutMsec(c, &timeout_msec) != REDIS_OK) {

__redisSetError(c, REDIS_ERR_IO, “Invalid timeout specified”);

goto error;

}

if (source_addr == NULL) {

free(c->tcp.source_addr);

c->tcp.source_addr = NULL;

} else if (c->tcp.source_addr != source_addr) {

free(c->tcp.source_addr);

c->tcp.source_addr = strdup(source_addr);

}

snprintf(_port, 6, “%d”, port);

memset(&hints,0,sizeof(hints));

hints.ai_family = AF_INET;

hints.ai_socktype = SOCK_STREAM;

if ((rv = getaddrinfo(c->tcp.host,_port,&hints,&servinfo)) != 0) {

hints.ai_family = AF_INET6;

if ((rv = getaddrinfo(addr,_port,&hints,&servinfo)) != 0) {

__redisSetError(c,REDIS_ERR_OTHER,gai_strerror(rv));

return REDIS_ERR;

}

}

for (p = servinfo; p != NULL; p = p->ai_next) {

addrretry:

if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == -1)

continue;

c->fd = s;

// 先设置套接字为非阻塞

if (redisSetBlocking(c,0) != REDIS_OK)

goto error;

if (c->tcp.source_addr) {

int bound = 0;

/* Using getaddrinfo saves us from self-determining IPv4 vs IPv6 */

if ((rv = getaddrinfo(c->tcp.source_addr, NULL, &hints, &bservinfo)) != 0) {

char buf[128];

snprintf(buf,sizeof(buf),“Can’t get addr: %s”,gai_strerror(rv));

__redisSetError(c,REDIS_ERR_OTHER,buf);

goto error;

}

if (reuseaddr) {

n = 1;

if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char*) &n,

sizeof(n)) < 0) {

goto error;

}

}

for (b = bservinfo; b != NULL; b = b->ai_next) {

if (bind(s,b->ai_addr,b->ai_addrlen) != -1) {

bound = 1;

break;

}

}

freeaddrinfo(bservinfo);

if (!bound) {

char buf[128];

snprintf(buf,sizeof(buf),“Can’t bind socket: %s”,strerror(errno));

__redisSetError(c,REDIS_ERR_OTHER,buf);

goto error;

}

}

if (connect(s,p->ai_addr,p->ai_addrlen) == -1) {

if (errno == EHOSTUNREACH) {

redisContextCloseFd©;

continue;

} else if (errno == EINPROGRESS && !blocking) {

/* This is ok. */

} else if (errno == EADDRNOTAVAIL && reuseaddr) {

if (++reuses >= REDIS_CONNECT_RETRIES) {

goto error;

} else {

redisContextCloseFd©;

goto addrretry;

}

} else {

//当connect出现EINPROGRESS 时继续处理

if (redisContextWaitReady(c,timeout_msec) != REDIS_OK)

goto error;

}

}

//若是阻塞方式连接，则设置套接字为阻塞方式

if (blocking && redisSetBlocking(c,1) != REDIS_OK)

goto error;

if (redisSetTcpNoDelay© != REDIS_OK)

goto error;

c->flags |= REDIS_CONNECTED;

rv = REDIS_OK;

goto end;

}

if (p == NULL) {

char buf[128];

snprintf(buf,sizeof(buf),“Can’t create socket: %s”,strerror(errno));

__redisSetError(c,REDIS_ERR_OTHER,buf);

goto error;

}

error:

rv = REDIS_ERR;

end:

freeaddrinfo(servinfo);

return rv; // Need to return REDIS_OK if alright

}

static int redisContextWaitReady(redisContext *c, long msec) {

struct pollfd wfd[1];

wfd[0].fd = c->fd;

wfd[0].events = POLLOUT;//若为EINPROGRESS，则继续处理完成的链接if (errno == EINPROGRESS) {

int res;

//使用poll等待连接完成

if ((res = poll(wfd, 1, msec)) == -1) {

__redisSetErrorFromErrno(c, REDIS_ERR_IO, “poll(2)”);

redisContextCloseFd©;

return REDIS_ERR;

} else if (res == 0) {

errno = ETIMEDOUT;

__redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);

redisContextCloseFd©;

return REDIS_ERR;

}

if (redisCheckSocketError© != REDIS_OK)

return REDIS_ERR;

return REDIS_OK;

}

__redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);

redisContextCloseFd©;

return REDIS_ERR;

}

int redisCheckSocketError(redisContext *c) {

int err = 0;

socklen_t errlen = sizeof(err);

if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {

__redisSetErrorFromErrno(c,REDIS_ERR_IO,“getsockopt(SO_ERROR)”);

return REDIS_ERR;

}

//若err不为0，说明异常，触发的事件不是链路的完成 if (err) {

errno = err;

__redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);

return REDIS_ERR;

}

return REDIS_OK;

}

对于调用 redisConnectNonBlock 方法进行非阻塞建立连接时，在redis中异步API函数 redisAsyncConnect 会调用该函数。

当使用redisConnectNonBlock 非阻塞调用时，c->flags 中去除了 REDIS_BLOCK标志，在_redisContextConnectTcp中不会执行redisContextWaitReady 函数，因此也就不知道connect是否成功，所以后续使用套接口时要进行判断链路是否建立成功。

在异步IO中，可写事件的回调函数是redisAeWriteEvent，该函数调用redisAsyncHandleWrite实现，在该函数中，如果上下文标志位中还没有设置REDIS_CONNECTED标记，说明目前还没有检测是否建链成功，因此调用__redisAsyncHandleConnect，判断建链是否成功，如果建链成功，则会在异步上下文的标志位中增加REDIS_CONNECTED标记，如果还没有建链成功，则直接返回。

static int __redisAsyncHandleConnect(redisAsyncContext *ac) {

redisContext *c = &(ac->c);

if (redisCheckSocketError© == REDIS_ERR) {

/* Try again later when connect(2) is still in progress. */

if (errno == EINPROGRESS)

return REDIS_OK;

if (ac->onConnect) ac->onConnect(ac,REDIS_ERR);

__redisAsyncDisconnect(ac);

return REDIS_ERR;

}

/* Mark context as connected. */

c->flags |= REDIS_CONNECTED;

if (ac->onConnect) ac->onConnect(ac,REDIS_OK);

return REDIS_OK;

}

int redisCheckSocketError(redisContext *c) {

int err = 0;

socklen_t errlen = sizeof(err);

if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {

__redisSetErrorFromErrno(c,REDIS_ERR_IO,“getsockopt(SO_ERROR)”);

return REDIS_ERR;

}

if (err) {

errno = err;

__redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);

return REDIS_ERR;

}

return REDIS_OK;

}

原文 链接
非阻塞的connect使用方式

喜欢本文的朋友，欢迎关注公众号 Linux码农，获取更多干货
在这里插入图片描述

Linux码农
关注
C++使用非阻塞式socket与select模型实现connect连接超时的控制（附源码）
dvlinker的技术专栏
07-26 468
本文讲述如何使用非阻塞式socket与select模型实现connect连接超时的控制。
非阻塞connect详解
weixin_42250655的博客
10-28 1331
我们先来讲connect函数(本文针对的是TCP) #include<sys/socket.h> int connect(int sockfd, const struct sockaddr* servaddr, socklen_t addrlen); 参数大家应该都知道，我在这里提一下，为什么第二个参数要用 struct sockaddr*？ 这是因为ANSI C标准为我们定义了一...
connect的非阻塞模式
最新发布
weixin_45419466的博客
07-22 670
一般情况下，在使用connect连接服务端时，需要等待一会儿才会函数才会返回，导致程序阻塞。为了降低阻塞的影响，我们可能会单独开个线程处理connect请求，例如在界面当中，就会启用一个线程，避免UI卡死。当然，这里还有一些其他的方法，也就是我们常见的非阻塞IO。
非阻塞connect()
热门推荐
shellching的专栏
06-14 1万+
说明：本文适用于Windows平台，后面追加一篇适用于Linux平台的 转自：http://www.cnblogs.com/shiqgfmj/archive/2010/12/29/1919434.html   非阻塞的socket客户端connect()困扰了一下午。因为是非阻塞，不管是否连接上都直接返回，所以就无法知道什么时候连接上。 一开始想到网上找资料，可惜不多。于是MSDN，总算找
Socket编程之非阻塞connect
weixin_34384681的博客
03-29 363
为什么80%的码农都做不了架构师？>>> ...
非阻塞connect
null
06-07 1550
一、用途： 1.提高程序效率 默认情况下connect函数是阻塞的，它发起TCP连接的三路握手。完成一个connect需要花费一个RTT时间（从本地主机到对端再回到本地）,RTT的波动范围很大，局域网上几毫秒到几百毫秒，广域网上甚至能需要几秒，这对计算机来说是非常漫长的时间，这段时间可以用来执行其他的处理工作，提高效率。因此非阻塞的connect函数是必要的。 2.同时建立多个连接，不必
网络编程--非阻塞connect
qq_20312079的博客
01-24 888
​ 看到Redis源码中主从复制的源码，对某些逻辑不是很确定。梳理了Redis非阻塞connect的大概实现之后，自己写了一个简单的版本。使用nc -l 8888当服务端，测试发现确实是可以通过监听POLLOUT事件来判断connect成功的。Linux高性能服务器编程[Ch9.5] 游双。
linux客户端Socket非阻塞connect编程[归纳].pdf
10-11
connect 操作需要花费一定的时间，可能会阻塞程序的执行，使用非阻塞 connect 可以在 connect 操作期间执行其他处理。 2. 建立多个连接。在 Web 浏览器中，非阻塞 connect 广泛应用于建立多个连接，以提高浏览器的...
linux客户端Socket非阻塞connect编程收集.pdf
11-04
Linux 客户端 Socket 非阻塞 connect 编程收集 本文档主要讨论了 Linux 客户端 Socket 非阻塞 connect 编程的实现与应用，非阻塞 connect 编程的主要用途有三种： 1. 三次握手同时做其他的处理。在 connect 过程中...
非阻塞connect编写方法介绍
夜影轩的专栏
12-07 8923
TCP连接的建立涉及到一个三次握手的过程，且SOCKET中connect函数需要一直等到客户接收到对于自己的SYN的ACK为止才返回，这意味着每个connect函数总会阻塞其调用进程至少一个到服务器的RTT时间，而RTT波动范围很大，从局域网的几个毫秒到几百个毫秒甚至广域网上的几秒。这段时间内，我们可以执行其他处理工作，以便做到并行。在此，需要用到非阻塞connect。本文主要介绍了非阻塞conn
connect函数非阻塞实现
dongyoubin的博客
07-22 1358
connect函数默认是长时间阻塞的，大概在一分钟左右。 下面将提供3种方法达到非阻塞或缩短阻塞时间，3种方法有可能出现不同的连接结果。 方法一： int netTCPConnect1(int ip,int port) { struct sockaddr_in address; int sockfd=-1; int flags=0; sockfd = socket(AF_INET,SOCK_STREAM,0); if(-1==sockfd) return -1; address.
非阻塞 Connect
weixin_30550271的博客
09-08 142
1.非阻塞Connect有什么用？ 可以让三路握手的处理等同与一般数据的处理，而不是一直让 connect一直尝试重连或者花费一个RTT时间。而且RTT时间从几毫秒到几秒不等，万一有许多连接，不论是尝试重连还是花费一个RTT时间，都将是致命的延时。 可以使用该技术同时建立多个连接。Web浏览器中常用。 既然使用select等待连接的建立，我们就可以质地不嗯一个时间限制，使得我们能够缩短conne...
非阻塞socket的连接
keke_zkt的专栏
03-05 1137
原文：http://os.chinaunix.net/a2010/0221/1061/000001061573_1.shtml 补充关于select在异步(非阻塞)connect中的应用,刚开始搞socket编程的时候 　　我一直都用阻塞式的connect,非阻塞connect的问题是由于当时搞proxy scan 　　而提出的呵呵 　　通过在网上与网友们的交流及查找相关FAQ
非阻塞connect的正确使用方式
多看多听多总结
04-03 648
首先创建reactive_socket_connect_op操作，调用start_connect_op，在套接字为非阻塞，或者将套接字设置为非阻塞，调用connect发起连接，如果错误码为in_progress或者would_block，将reactive_socket_connect_op操作添加到事件循环中，在套接字变为可写时，会执行reactive_socket_connect_op_base基类的do_perform方法，其会调用socket_ops#non_blocking_connect方法。
非阻塞connect的实现
The time is passing
09-30 366
步骤1： 设置非阻塞，启动连接 实现非阻塞 connect ，首先把 sockfd 设置成非阻塞的。这样调用 connect 可以立刻返回，根据返回值和 errno 处理三种情况： (1) 如果返回 0，表示 connect 成功。 (2) 如果返回值小于 0， errno 为 EINPROGRESS,  表示连接       建立已经启动但是尚未完成。这是期望的结果，不是真正的错误。...
非阻塞的connect
我是一片云
03-04 290
Linux 怎样实现非阻塞connect 转载http://blog.youkuaiyun.com/to_be_better/article/details/53069583 前言 凡是接触过socket编程的，对connect函数一定不陌生。因为socket是面向连接的，所以在进行读写操作前我们首先要进行连接，而所谓连接也就是我们常说的三次握手，这个过程就是在connect函数中完成的。 虽然c...
使用select非阻塞实现socket编程详解
标签“socket 非阻塞”指向的是上述描述中使用的非阻塞Socket编程和`select`函数的组合使用。在实际应用中，通过非阻塞Socket以及`select`函数可以有效地管理大量的客户端连接，并且提高服务器对客户端请求的响应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值