主页 / coding / 问题 / 78918013
Accepted
Vincent
Asked: 2024-08-27 17:03:32 +0800 CST

使用鉴别器进行快速去抖动或延迟

  • 772

我的应用程序包含各种小部件，用于指示实时值（​​温度、CPU 使用率、内存等）。这些小部件通过单个 websocket 收到的 JSON 消息进行更新。

目前，更新是实时处理的，因此一旦收到新值，我就会更新我的小部件。

讯息如下：{widget: "widgetId", value: 150}。

我的问题是，有时同一个小部件每秒会进行多次更新，这会导致屏幕闪烁，并产生无用的性能成本。我想通过延迟 UI 更新以仅在一段时间内使用最新收到的值进行更新来减少这种情况。

我想探讨以下两个选择：

  1. 每 X 秒同时更新所有小部件一次（通过仅保留每个小部件的最新更新并将它们一次全部发送到 UI）。

  2. 每 X 秒最多更新一次小部件（通过通道去抖动）。

我的套接字处理程序如下所示：

socket.receive(completionHandler: { [weak self] result in
    switch result {
        case .success(let message):
            switch message {
                case .data(let data):
                    guard let update = try? WidgetUpdate(serializedData: data) else {
                         print("Failed to deserialize data")
                         return
                     }
                     DispatchQueue.main.async {
                         self?.updateWidget(update: update)
                     }
                     @unknown default:
                         print("unknown")
            }
        }
    }
)

到目前为止我尝试的是使用PassthroughSubject这样的方法：

let subject = PassthroughSubject<WidgetUpdate, Never>()
cancellable = subject
    .debounce(for: .seconds(0.5), scheduler: RunLoop.main)
    .sink { update in
        self?.updateWidget(update: update)
    }

// And to publish inside the publisher from the socket handler like this
subject.send(update)

问题是它显然会消除“所有”更新的抖动，而不是通过小部件。
我想避免通过小部件创建一个 PassthroughSubject，因为可以动态添加或删除小部件，并且我不想管理相关发布者的创建/删除。

swift

1 个回答

  1. Best Answer

    我认为 ReactiveX GroupBy操作符会对你有所帮助。不幸的是，Combine 没有自带的 GroupBy，但可以通过扫描来实现：

    import Combine
import Foundation

extension Publisher {
    public func grouped<Key: Hashable> (
        by key: @escaping (Self.Output) -> Key
    ) -> some Publisher<CurrentValueSubject<Self.Output, Never>, Self.Failure> {
        scan(([:], nil)) { (accum: ([Key: CurrentValueSubject<Self.Output, Never>], CurrentValueSubject<Self.Output, Never>?), next) in
            var (accumPubs, _) = accum
            if let existingSubject = accumPubs[key(next)] {
                existingSubject.send(next)
                
                return (accumPubs, nil)
            } else {
                let newSubject = CurrentValueSubject<Self.Output, Never>(next)
                accumPubs[key(next)] = newSubject
                
                return (accumPubs, newSubject)
            }
        }.compactMap { $0.1 }
    }
}

    一旦你有了这个，我相信类似这样的事情应该可以解决你的问题（这是基于你原来的例子）：

    struct Element {
    let channel: String
    let updateNum: Int
}
var subscriptions: Set<AnyCancellable> = Set()
withExtendedLifetime(subscriptions) {
    let pub1 = Just(Element(channel: "chan1", updateNum: 1)).delay(for: .seconds(0.1), scheduler: RunLoop.main)
    let pub2 = Just(Element(channel: "chan2", updateNum: 1)).delay(for: .seconds(0.2), scheduler: RunLoop.main)
    let pub3 = Just(Element(channel: "chan1", updateNum: 2)).delay(for: .seconds(0.2), scheduler: RunLoop.main)
    let pub4 = Just(Element(channel: "chan1", updateNum: 3)).delay(for: .seconds(0.3), scheduler: RunLoop.main)
    let pub5 = Just(Element(channel: "chan2", updateNum: 2)).delay(for: .seconds(0.4), scheduler: RunLoop.main)
    let pub6 = Just(Element(channel: "chan2", updateNum: 3)).delay(for: .seconds(0.5), scheduler: RunLoop.main)
    let pub7 = Just(Element(channel: "chan1", updateNum: 4)).delay(for: .seconds(0.6), scheduler: RunLoop.main)
    let pub = Publishers.MergeMany(pub1, pub2, pub3, pub4, pub5, pub6, pub7)
    pub
        .grouped { $0.channel }
        .flatMap {
            $0.debounce(for: .seconds(0.3), scheduler: RunLoop.main)
            // Or:
            // $0.throttle(for: .seconds(0.3), scheduler: RunLoop.main, latest: true)
        }
        .sink { result in print(result) }
        .store(in: &subscriptions)
}
RunLoop.main.run()

    以下是根据您的实际 WebSocket 问题得出的一些结论：

    let subject = PassthroughSubject<WidgetUpdate, Never>()
cancellable = subject
    .grouped { $0.widget }
    .flatMap {
        $0.debounce(for: .seconds(0.5), scheduler: RunLoop.main)
        // Or:
        // $0.throttle(for: .seconds(0.5), scheduler: RunLoop.main, latest: true)
    }
    .sink { update in
        self?.updateWidget(update: update)
    }

// And to publish inside the publisher from the socket handler like this
subject.send(update)

    此外，在我看来，您真正想要的是节流，而不是防抖动，尽管对于您的用例，大多数用户可能不会注意到两者之间的区别。只要您将发布者分组，您就可以选择节流或防抖动。

    • 1

相关问题