Kotlin 将RX迁移到协同程序

我开始学习合作 这段代码在协同程序上是什么样子的？ 我想离开RX 并开始使用协同程序

open class DataState<out T>(val newState: T, val oldState: T?, val json: String)
object EventBus {
    private val dataPublisher: MutableMap<String, PublishSubject<DataState<Any>>> = mutableMapOf()

    inline fun <reified T : Any> fire(event: DataState<T>) = fire(T::class.java.name, event)
    fun <T : Any> fire(clazz: Class<T>, event: DataState<T>) = EventBus.fire(clazz.name, event)

    fun <T : Any> fire(className: String, event: DataState<T>) {
        synchronized(this) {
            dataPublisher[className]?.onNext(event)
        }
    }

    inline fun <reified T : Any> on(): Observable<DataState<T>> = on(T::class.java)

    fun <T> on(dataType: Class<T>): Observable<DataState<T>> {

        synchronized(this) {
            var pub = dataPublisher[dataType.name]

            if (pub == null) {
                pub = PublishSubject.create()
                dataPublisher[dataType.name] = pub
            }

            return pub.ofType(DataState::class.java) as Observable<DataState<T>>
        }
    }

    fun reset() {
        synchronized(this) {
            dataPublisher.values.forEach { it.onComplete() }
            dataPublisher.clear()
        }
    }
}

开放类数据状态（val newState:T，val oldState:T？，val json:String）
对象事件总线{
private val dataPublisher:MutableMap=mutableMapOf（）
内联fun fire（事件：DataState）=fire（T:：class.java.name，事件）
趣味火灾（clazz:Class，event:DataState）=EventBus.fire（clazz.name，event）
趣味火灾（类名：String，事件：DataState）{
已同步（此）{
dataPublisher[className]？.onNext（事件）
}
}
inline fun on（）：Observable=on（T:：class.java）
有趣的（数据类型：类）：可观察{
已同步（此）{
var pub=dataPublisher[dataType.name]
if（pub==null）{
pub=PublishSubject.create（）
dataPublisher[dataType.name]=发布
}
将pub.ofType（DataState:：class.java）返回为可观察
}
}
趣味重置（）{
已同步（此）{
dataPublisher.values.forEach{it.onComplete（）}
dataPublisher.clear（）
}
}
}

---

我真的不知道如何对协同程序做同样的事情，但我愿意接受这样的可能性，那将是一种改进。有人能告诉我如何使用协同程序实现这一点，并解释协同程序方式的优点吗？

协同程序只处理RxJava所处理的宇宙的一部分。例如，如果没有RxJava，对计时、线程或流控制的控制就会困难得多。例如，如果没有RxJava，对计时、线程或流控制的控制要困难得多。