1. TCP连接超时简介

TCP是面向连接的协议,通过三次握手建立连接,但是,在建立连接的过程中对方有可能没有响应,这时候发起连接的一方会重试,如果重试多次仍然没有响应,就会触发超时,从而导致连接失败,socket的connect方法支持通过参数设置连接超时时间,默认情况下也可以使用缺省的超时时间,那么,问题来了:

  1. 连接的默认超时时间是多少?
  2. 如果超时时间设置为0会怎么样?
  3. 如果超时时间设置的非常大,比如5分钟,套接字会一直尝试连接吗?

要回答这些问题还不太容易,官方文档也没有给出,下面咱们就自己尝试下,寻找问题的答案。

2.TCP连接超时示例

本示例通过TCP套接字尝试连接一个不存在的IP地址,所以肯定会连接失败,示例中共尝试了5次,第一次使用默认的超时时间,第二次使用0超时时间,第三次使用3秒超时时间,第四次使用30秒超时时间,第五次使用300秒超时时间,每次连接前后都记录下当时的时间,从而方便分析实际耗费的时间。本示例运行后的截图如下所示:

img

下面详细介绍创建该应用的步骤。

步骤1:创建Empty Ability项目。

步骤2:在module.json5配置文件加上对权限的声明:

"requestPermissions": [

{

​ "name": "ohos.permission.INTERNET"

},

{

​ "name": "ohos.permission.GET_WIFI_INFO"

}

]

这里分别添加了访问互联网和访问WIFI信息的权限。

步骤3:在Index.ets文件里添加如下的代码:

import socket from '@ohos.net.socket';
import wifiManager from '@ohos.wifiManager';
import systemDateTime from '@ohos.systemDateTime';

//说明:本地的IP地址不是必须知道的,绑定时绑定到IP:0.0.0.0即可,显示本地IP地址的目的是方便对方发送信息过来
//本地IP的数值形式
let ipNum = wifiManager.getIpInfo().ipAddress
//本地IP的字符串形式
let localIp = (ipNum >>> 24) + '.' + (ipNum >> 16 & 0xFF) + '.' + (ipNum >> 8 & 0xFF) + '.' + (ipNum & 0xFF);

@Entry
@Component
struct Index {
  //连接、通讯历史记录
  @State msgHistory: string = ''

  //服务端IP地址
  @State serverIp: string = "0.0.0.0"
  //服务端端口
  @State serverPort: number = 9999
  scroller: Scroller = new Scroller()

  build() {
    Row() {
      Column() {
        Text("TCP连接超时演示")
          .fontSize(14)
          .fontWeight(FontWeight.Bold)
          .width('100%')
          .textAlign(TextAlign.Center)
          .padding(10)

        Flex({ justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
          Text("本地IP:")
            .width(100)
            .fontSize(14)
            .flexGrow(0)
          Text(localIp)
            .width(110)
            .fontSize(12)
            .flexGrow(0)
        }.width('100%')
        .padding(5)

        Flex({ justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
          Text("服务端地址:")
            .fontSize(14)
            .width(90)
            .flexGrow(0)

          TextInput({ text: this.serverIp })
            .onChange((value) => {
              this.serverIp = value
            })
            .width(110)
            .fontSize(12)
            .flexGrow(1)
          Text(":")
            .width(5)
            .flexGrow(0)

          TextInput({ text: this.serverPort.toString() })
            .type(InputType.Number)
            .onChange((value) => {
              this.serverPort = parseInt(value)
            })
            .fontSize(12)
            .flexGrow(0)
            .width(60)
        }
        .width('100%')
        .padding(5)

        Flex({ justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
          Text("默认超时时间:")
            .fontSize(14)
            .width(130)
            .flexGrow(0)

          Text("default")
            .width(110)
            .fontSize(12)
            .flexGrow(1)

          Button("连接测试")
            .onClick(() => {
              this.connect2Server(true, 0)
            })
            .width(110)
            .fontSize(14)
            .flexGrow(0)
        }
        .width('100%')
        .padding(5)

        Flex({ justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
          Text("超时时间为0:")
            .fontSize(14)
            .width(130)
            .flexGrow(0)

          Text("0")
            .width(110)
            .fontSize(12)
            .flexGrow(1)

          Button("连接测试")
            .onClick(() => {
              this.connect2Server(false, 0)
            })
            .width(110)
            .fontSize(14)
            .flexGrow(0)
        }
        .width('100%')
        .padding(5)

        Flex({ justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
          Text("超时时间为3秒:")
            .fontSize(14)
            .width(130)
            .flexGrow(0)

          Text("3000")
            .width(110)
            .fontSize(12)
            .flexGrow(1)

          Button("连接测试")
            .onClick(() => {
              this.connect2Server(false, 3000)
            })
            .width(110)
            .fontSize(14)
            .flexGrow(0)
        }
        .width('100%')
        .padding(5)

        Flex({ justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
          Text("超时时间为30秒:")
            .fontSize(14)
            .width(130)
            .flexGrow(0)

          Text("30000")
            .width(110)
            .fontSize(12)
            .flexGrow(1)

          Button("连接测试")
            .onClick(() => {
              this.connect2Server(false, 30000)
            })
            .width(110)
            .fontSize(14)
            .flexGrow(0)
        }
        .width('100%')
        .padding(5)

        Flex({ justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
          Text("超时时间为300秒:")
            .fontSize(14)
            .width(130)
            .flexGrow(0)

          Text("300000")
            .width(110)
            .fontSize(12)
            .flexGrow(1)

          Button("连接测试")
            .onClick(() => {
              this.connect2Server(false, 300000)
            })
            .width(110)
            .fontSize(14)
            .flexGrow(0)
        }
        .width('100%')
        .padding(5)

        Scroll(this.scroller) {
          Text(this.msgHistory)
            .textAlign(TextAlign.Start)
            .padding(5)
            .width('100%')
            .backgroundColor(0xeeeeee)
        }
        .align(Alignment.Top)
        .backgroundColor(0xeeeeee)
        .height(300)
        .flexGrow(1)
        .scrollable(ScrollDirection.Vertical)
        .scrollBar(BarState.On)
        .scrollBarWidth(20)
      }
      .width('100%')
      .justifyContent(FlexAlign.Start)
      .height('100%')
      .padding(5)
    }
    .height('100%')
  }

  //连接服务端
  async connect2Server(defaultTimeout: boolean, timeout: number) {
    //执行TCP通讯的对象
    let tcpSocket = socket.constructTCPSocketInstance();

    let localAddress = { address: "0.0.0.0", family: 1 }

    await tcpSocket.bind(localAddress)

    //服务端地址
    let serverAddress = { address: this.serverIp, port: this.serverPort, family: 1 }

    let option: socket.TCPConnectOptions = { address: serverAddress }
    if (!defaultTimeout) {
      option = { address: serverAddress, timeout: timeout }
      this.msgHistory += "连接超时时间设置:" + timeout.toString() + "\r\n";
    } else {
      this.msgHistory += "连接超时时间设置:default" + "\r\n";
    }

    this.msgHistory += "连接开始时间:" + await  getCurrentTimeString() + "\r\n";
    await tcpSocket.connect(option)
      .then(() => {
        this.msgHistory += 'connect success ' + "\r\n";
      })
      .catch(async (e) => {
        this.msgHistory += 'connect fail ' + e.message + "\r\n";
        this.msgHistory += "连接结束时间:" + await getCurrentTimeString() + "\r\n\r\n";
      })

    await tcpSocket.close()
  }
}

//同步获取当前时间的字符串形式
async function getCurrentTimeString() {
  let time = ""
  await  systemDateTime.getDate().then(
    (date) => {
      time = date.getHours().toString() + ":" + date.getMinutes().toString()
      + ":" + date.getSeconds().toString() + ":" + date.getMilliseconds().toString()
    }
  )
  return "[" + time + "]"
}

步骤4:编译运行,可以使用模拟器或者真机。

步骤5:配置服务端IP和端口,一定要设置不存在的地址,然后逐次单击“连接测试”按钮,执行后的截图如下所示:

img

截图的最后是连接日志信息:

img

3.TCP连接超时分析

从输出的日志可以分析如下:

1.默认的超时时间为5秒钟

2.超时时间设置为0时,按照5秒钟计算超时时间

3.设置3秒钟或者30秒钟,实际超时时间就是3秒钟或者30秒钟

4.设置大于65秒的超时时间,实际超时时间为65秒左右

前3个好理解,最后这个65秒是怎么回事呢?这里分析一下,实际上,TCP连接重试时执行等待时间翻倍的规则,也就是连接失败后等待1秒钟重试,再失败等待2秒钟,然后依次是4秒钟、8秒钟、16秒钟、32秒钟,linux默认重试5次,也就是1+2+4+8+16+32=63秒钟,再加上其他耗费的时间,所以表现出来最大超时时间是65秒左右。

怎么样,是不是对鸿蒙系统下TCP连接超时时间有了更清晰的认识呢?

(本文作者原创,除非明确授权禁止转载)

本文源码地址:

https://gitee.com/zl3624/harmonyos_network_samples/tree/maste...

本系列源码地址:

https://gitee.com/zl3624/harmonyos_network_samples


长弓三石
1 声望0 粉丝