Question

我对Swift编程很新，请原谅我在下面要问的虚拟问题。

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

我应该在哪里建立与服务器的连接？（我应该在第一个视图控制器的viewDidLoad（）函数中建立连接吗？）
我应该在哪里创建一个线程来安排函数调用？如果我在第一个视图控制器中创建线程，那么在切换到另一个视图控制器后线程是否会死？
我应该为该线程使用什么QoS级别？该应用程序每秒渲染从服务器接收的数据，因此我认为此任务具有非常高的优先级。

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

提前致谢！

Answer 1

据我所知，可以对问题中提出的情景进行以下操作

如果您要在启动应用后立即与服务器建立连接。我认为最好在下面的AppDelegate didFinishLaunchingWithOptions中进行此操作
```
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。

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

Answer 2

经过一番挖掘，我找到了在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这样的通信模式会严重影响服务器的客户端请求，因此不推荐使用。

为Swift调度套接字通信

2 个答案: