Question

我正在开发一个聊天应用程序，该应用程序一次可以接收许多消息，从而导致应用程序冻结。以下是我的套接字接收器：

func receiveNewDirectMessages() {
    self.socket?.on(EventListnerKeys.message.rawValue, callback: { (arrAckData, ack) in
        print_debug(arrAckData)
        guard let dictMsg = arrAckData.first as? JSONDictionary else { return }
        guard let data = dictMsg[ApiKey.data] as? JSONDictionary else { return }
        guard let chatData = data[ApiKey.data] as? JSONDictionary else { return }
        guard let messageId = chatData[ApiKey._id]  as? String , let chatId = chatData[ApiKey.chatId] as? String else { return }
        if MessageModel.getMessageModel(msgId: messageId) != nil { return }
        let isChatScreen = self.isChatScreen
        let localMsgId = "\(arc4random())\(Date().timeIntervalSince1970)"
        if let senderInfo = data[ApiKey.senderInfo] as? JSONDictionary, let userId = senderInfo[ApiKey.userId] as? String, userId != User.getUserId() {
            _ = AppUser.writeAppUserModelWith(userData: senderInfo)
        }
        let msgModel = MessageModel.saveMessageData(msgData: chatData, localMsgId: localMsgId, msgStatus: 2, seenByMe: false)
        let chatModel = ChatModel.saveInboxData(localChatId: msgModel.localChatId, inboxData: chatData)
        if isChatScreen {
            self.emitMessageStatus(msgId: messageId, chatId: chatId, socketService: .messageStatus, status: .delivered)
            self.emitMessageStatus(msgId: messageId, chatId: chatId, socketService: .messageStatus, status: .seen)
        } else {
            ChatModel.updateUnreadCount(localChatId: chatModel.localChatId, incrementBy: 1)
            self.emitMessageStatus(msgId: messageId, chatId: chatId, socketService: .messageStatus, status: .delivered)
        }
        TabController.shared.updateChatBadgeCount()
    })
}

上面发生了什么： 1.我正在此套接字侦听器中一对一接收所有未传递的消息。 2.获取消息数据 3.将收到的发件人信息保存到Realm DB 4.将消息模型保存到领域数据库 5.在领域数据库中保存/更新聊天线程 6.发出对收到消息的确认 7.更新标签栏上的聊天徽章计数

下面是我确认消息传递的发射器。

 func emitMessageStatus(msgId: String, chatId: String, socketService: SocketService, status: MessageStatusAction) {

    // Create Message data packet to be sent to socket server
    var msgDataPacket = [String: Any]()
    msgDataPacket[ApiKey.type] = socketService.type
    msgDataPacket[ApiKey.actionType] = socketService.listenerType
    msgDataPacket[ApiKey.data] = [
        ApiKey.messageId: msgId,
        ApiKey.chatId: chatId,
        ApiKey.userId: User.getUserId(),
        ApiKey.statusAction: status.rawValue
    ]
    // send the messsage  data packet to socket server & wait for the acknowledgement
    self.emit(with: EventListnerKeys.socketService.rawValue, msgDataPacket) { (arrAckData) in
        print_debug(arrAckData)
        guard let dictMsg = arrAckData.first as? JSONDictionary else { return }
        if let msgData = dictMsg[ApiKey.data] as? [String: Any] {
            // Update delivered Seen Status here
            if let msgId = msgData[ApiKey.messageId] as? String, let actionType = msgData[ApiKey.statusAction] as? String, let msgStatusAction = MessageStatusAction(rawValue: actionType) {
                switch msgStatusAction {
                case .delivered:
                    if let deliveredTo = msgData[ApiKey.deliveredTo] as? [[String: Any]] {
                        _ = MessageModel.updateMsgDelivery(msgId: msgId, deliveredTo: deliveredTo)
                    }
                case .seen:
                    if let seenBy = msgData[ApiKey.seenBy] as? [[String: Any]] {
                        _ = MessageModel.updateMsgSeen(msgId: msgId, seenBy: seenBy)
                    }
                case .pin:
                    MessageModel.clearPinnedMessages(chatId: chatId)
                    if let pinTime = msgData[ApiKey.pinTime] as? Double {
                        MessageModel.updatePinnedStatus(msgId: msgId, isPinned: true, pinTime: pinTime)
                    }
                case .unPin:
                    if let pinTime = msgData[ApiKey.pinTime] as? Double {
                        MessageModel.updatePinnedStatus(msgId: msgId, isPinned: false, pinTime: pinTime)
                    }
                case .delete:
                    MessageModel.deleteMessage(msgId: msgId)
                case .ackMsgStatus, .like, .unlike:
                    break
                }
            }
        }
    }
}

上面发生了什么

封装所有相关信息以确认事件
确认交付后更新领域数据库

现在，我无法在这里违背完美的线程策略。在后台线程中写什么，我应该在主线程中写什么。但是，我尝试这样做，但这会导致随机崩溃或数据包丢失。

任何人都可以在这个主题上引导我前进。我将非常感谢。

Answer 1

尝试使用后台线程进行数据处理/非UI处理。
减少UI更新次数

使用去抖动-而不是处理1对1消息。您可以存储新消息，然后使用n条新消息更新UI。因此，您可以将100条消息更新1次，而不是将UI /将数据保存到db 100次以更新100条消息。更多详细信息：将每条新消息添加到数组中。呼叫去抖动器。 Debouncer将延迟函数调用，并且每次调用该函数时，它都会延迟前一个调用，直到延迟时间结束。因此，例如在200毫秒后，如果没有新消息，则将调用update func（用于反跳处理的回调函数）。然后使用新存储的n条消息更新ui / db。

您可以按时间分组消息，例如按1小时分组。然后在每个时间组之间进行延迟更新。您可以在调用去抖器->按时间分组消息->每个组更新db / ui时执行此操作。您可以使用setTimeout，例如更新组1，在100毫秒后更新更新组2，这样ui不会被冻结

从Socket接收批量数据时，应用冻结。 iOS | Socket.io | RealmSwift

1 个答案: