为 Swift 调度套接字通信

我对 Swift 编程相当陌生，请原谅我在下面要问的虚拟问题。

在我的应用程序中，我正在尝试调度调用一个函数，该函数将从我的服务器接收一些数据，并且每秒都会调用一次。通信需要通过TCP套接字实现。在做了一些研究之后，在我看来，我需要一种方法来正确使用线程来调用该函数。所以我的问题来了：

我应该在哪里连接到服务器？(我应该在我的第一个视图控制器的 viewDidLoad(( 函数中建立连接吗？
我应该在哪里创建线程来计划函数调用？如果我在第一个视图控制器中创建线程，切换到另一个视图控制器后线程会死亡吗？
我应该为该线程使用什么 QoS 级别？该应用程序每秒都会呈现从服务器接收的数据，因此我认为此任务的优先级非常高。

我尝试查找有关线程和套接字通信的教程和示例，但找不到适用于我的应用程序的信息。因此，任何有关设计的帮助或见解将不胜感激！

提前感谢！

据我说，对于问题中提出的场景，可以执行以下操作

如果您要在启动应用程序后立即连接到服务器。我相信最好在下面给出的didFinishLaunchingWithOptions AppDelegate
这样做
```
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
}
```
这取决于您将如何切换到其他ViewController。在切换过程中，如果您要释放当前ViewController，那么您的线程将死亡。

考虑到您正在制作一个基于套接字的应用程序，并且您将每秒从服务器接收数据。然后，NSURLSession可能对您没有太大帮助。对于套接字通信，通常使用NSInputStream和NSOutputStream。下面这个来自 objective-C 的例子可能会帮助你入门：

 - (void)connectWithHostFromUrl: (NSURL *)hostUrl {
        CFReadStreamRef readStream;
        CFWriteStreamRef writeStream;
        CFStreamCreatePairWithSocketToHost(NULL, (__bridge CFStringRef)[hostUrl host], 80, &readStream, &writeStream);
       _inputStream = (__bridge_transfer NSInputStream *)readStream;
       [_inputStream setDelegate:self];
       [_inputStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];
       [_inputStream open];
       _outputStream = (__bridge_transfer NSOutputStream *)writeStream;
       [_outputStream setDelegate:self];
       [_outputStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];
       [_outputStream open];
  }
 // Delegate methods
- (void)stream:(NSStream *)aStream handleEvent:(NSStreamEvent)eventCode {
        switch (eventCode) {
             case NSStreamEventNone:
             {
              // handle it according to your need
             }
                  break;
             case NSStreamEventOpenCompleted:
             {
              // handle it according to your need
             }
                  break;
             case NSStreamEventHasBytesAvailable:
             {
                 if (_receivedData == nil) {
                      _receivedData = [NSMutableData new];
                 }
                 uint8_t buffer[1024];
                 NSInputStream *inputStream = (NSInputStream *)aStream;
                 NSInteger bytesReceived = [inputStream read:buffer maxLength:1024];
                if (bytesReceived > 0) {
                    [_receivedData appendBytes:(const void *)buffer length:bytesReceived];
                }
             }
                  break;
             case NSStreamEventHasSpaceAvailable:
             {
                  if (_dataToSend != nil) {
                    // _dataToSend is NSMutableData/NSData object
                      NSOutputStream *outputStream = (NSOutputStream *)aStream;
                      const uint8_t *mutableBytes = (const uint8_t *)[_dataToSend mutableBytes];
                      NSInteger length = [_dataToSend length]/sizeof(uint8_t);
                      [outputStream write:(const uint8_t *)mutableBytes maxLength:length];
                  }
              }
                  break;
              case NSStreamEventErrorOccurred:
              {
                // handle it according to your need
              }
                  break;
              case NSStreamEventEndEncountered:
              {
                // handle it according to your need
              }
                  break;
              default:
                  break;
       }
}

由于这里有很多案件要处理。大多数时候，我建议使用经过测试的第三方库，如SocketRocket。

请建议编辑以使此答案更好:)

经过一番挖掘，我找到了在 Swift 端实现流编程的方法(使用原生 Swift 功能(。事实证明，Swift 中的方式与 Objective C 中的方式非常相似。

在 Swift 中启用流编程所需的两个函数是 func connect() 个，这是我自己必须自己编写的，func stream(_ aStream: Stream, handle eventCode: Stream.Event) 是作为 StreamDelegate 中的方法提供的。

以下是func connect()的外观：

func connect() {
    Stream.getStreamsToHost(withName: <serverIP>, port: <serverPort>, inputStream: &inputStream, outputStream: &)
    guard let inputStream = inputStream, let outputStream = outputStream else {
        print(" ->tNetworkControllerError: Cannot open inputstream/outputstream.")
        return
    }
    // Set delegate
    inputStream.delegate = self
    outputStream.delegate = self
    let socketWorkQueue = DispatchQueue(label: "socketWorkQueue", attributes: .concurrent)
    CFReadStreamSetDispatchQueue(inputStream, socketWorkQueue)
    CFWriteStreamSetDispatchQueue(outputStream, socketWorkQueue)
    inputStream.open()
    outputStream.open()
}

这是func stream(_ aStream: Stream, handle eventCode: Stream.Event)的样子：

func stream(_ aStream: Stream, handle eventCode: Stream.Event) {
    if aStream === inputStream {
        switch eventCode {
        case Stream.Event.errorOccurred:
            streamEventQueue.async {
                // do something here
            }
            break
        case Stream.Event.openCompleted:
            streamEventQueue.async {
                // do something here
            }
            break
        case Stream.Event.hasBytesAvailable:
            streamEventQueue.async {
                // do something here
                let output = read()
            }
            break
        case Stream.Event.endEncountered:
            streamEventQueue.async {
                // do something here
            }
            break
        default:
            break
        }
    }
    else if aStream === outputStream {
        switch eventCode {
        case Stream.Event.errorOccurred:
            streamEventQueue.async {
                // do something here
            }
            break
        case Stream.Event.openCompleted:
            streamEventQueue.async {
                // do something here
            }
            break
        default:
            break
        }
    }
}

因此，stream()函数应该是我的应用程序中处理由网络连接/断开连接引起的状态转换的唯一位置。请注意，我还使用串行事件队列来处理流事件。这是为了防止可能导致国家腐败的任何潜在竞争条件。

对于那些不太熟悉流编程的人来说，这是一种服务器-客户端通信模式，可以保持连接/套接字的活动。连接需要保持活动状态，主要是因为服务器和客户端之间存在持续的通信。像 RESTful API 这样的通信模式会因客户端的请求而给服务器带来沉重的负担，因此不建议这样做。

相关内容

最新更新

热门标签：