有一个集成了RxJava和协程的库：https://github.com/Kotlin/kotlinx.coroutines/tree/master/reactive/kotlinx-coroutines-rx2
但是在那个库中没有直接将single转换为Deferred的函数，原因可能是RxJava Single没有绑定到协程作用域，如果你想将它转换为Deferred，你需要提供一个CoroutineScope。
您可能会像这样实现它：

fun <T> Single<T>.toDeferred(scope: CoroutineScope) = scope.async { await() }

Single.await函数（用于async块）来自kotlinx-coroutines-rx 2库。
您可以像这样调用函数：

coroutineScope {
    val mySingle = getSingle()
    val deferred = mySingle.toDeferred(this)
}

只需将您的单曲设置为暂停功能：

suspend fun waitForRxJavaResult(): String? = suspendCoroutine { cont ->
        try {
            val result = resultSingle.blockingGet()
            cont.resume(result)
        } catch (e: Exception){
            cont.resume(null)
        }
    }

implementation 'io.reactivex.rxjava2:rxandroid:+'
implementation 'io.reactivex.rxjava2:rxjava:+'
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-rx2:+'

并在代码中添加：

fun <T> Maybe<T>.toDeferred(coroutineScope: CoroutineScope) = coroutineScope.async { awaitSingleOrNull() }

fun <T> Single<T>.toDeferred(coroutineScope: CoroutineScope) = coroutineScope.async { await() }

用法：

lifecycleScope.launch {
            val result = getItemMaybe().toDeferred(this).await()
            ...
        }


 fun getItemMaybe(): Maybe<Int> {
       
 }

这个怎么👇样

suspend fun <T> Observable<out T>.toCoroutine(): T {
  return suspendCancellableCoroutine { continuation ->
    val subscription = this.subscribe(
      { continuation.resume(it) },
      { continuation.resumeWithException(it) }
    )
    continuation.invokeOnCancellation {
      subscription.unsubscribe()
    }
  }
}

我尝试用suspendCancellableCoroutine块生成器将回调方面转换为协程！

这将RxJava2 Single转换为带取消的暂停乐趣。

suspend fun <T> Single<T>.await(): T {
    return suspendCancellableCoroutine { cont ->
        val disposable = subscribe({ cont.resume(it) }, { cont.resumeWithException(it) })
        cont.invokeOnCancellation { disposable.dispose() }
    }
}