标签: kotlin-coroutines

我目前正在尝试更多地利用 kotlin 协程。但我面临一个问题：在这些协程中使用 moshi 或 okhttp 时，我收到警告：

“不适当的阻塞方法调用”

解决这些问题的最佳方法是什么？我真的不想不合适;-)

在kotlinx.coroutines库中,您可以使用launch(with join)或async(with await)启动新的协同程序.他们之间有什么区别？

Google 正在弃用 Android 11 中的 Android AsyncTask API，并建议java.util.concurrent改用。你可以在这里查看提交

 *
 * @deprecated Use the standard <code>java.util.concurrent</code> or
 *   <a href="https://developer.android.com/topic/libraries/architecture/coroutines">
 *   Kotlin concurrency utilities</a> instead.
 */
@Deprecated
public abstract class AsyncTask<Params, Progress, Result> {

如果您在 Android 中维护带有异步任务的旧代码库，则将来可能需要对其进行更改。我的问题是，使用java.util.concurrent. 它是一个 Activity 的静态内部类。我正在寻找可以使用的东西minSdkVersion 16

private static class LongRunningTask extends AsyncTask<String, Void, MyPojo> {
        private static final String TAG = MyActivity.LongRunningTask.class.getSimpleName();
        private WeakReference<MyActivity> activityReference;

        LongRunningTask(MyActivity context) {
            activityReference = new WeakReference<>(context);
        }

        @Override
        protected MyPojo doInBackground(String... params) { …

Kotlin协程可以用于生产,它们的实验状态意味着什么？

我一直是kotlin文档,如果我理解正确,两个kotlin函数的工作原理如下:

1. withContext(context):切换当前协同程序的上下文,当给定的块执行时,协同程序切换回上一个上下文.
2. async(context):在给定的上下文中启动一个新的协同程序,如果我们调用.await()返回的Deferred任务,它将挂起调用协程并在生成的协同程序内执行的块返回时恢复.

现在为以下两个版本code:

版本1:

  launch(){
    block1()
    val returned = async(context){
      block2()
    }.await()
    block3()
  }

版本2:

  launch(){
    block1()
     val returned = withContext(context){
      block2()
    }
    block3()
  }

1. 在两个版本中,block1(),block3()在默认上下文(commonpool？)中执行,其中block()在给定的上下文中执行.
2. 整体执行与block1() - > block2() - > block3()顺序同步.
3. 我看到的唯一区别是version1创建了另一个协程,其中version2在切换上下文时只执行一个协同程序.

我的问题是:

1. 使用它并不总是更好,withContext而不是async-await功能相似,但不会创建另一个协同程序.大型数字协程,虽然轻量级仍然是要求苛刻的应用程序中的问题

2. 是否有async-await更优先的案例withContext

更新: Kotlin 1.2.50现在有一个可以转换的代码检查async(ctx) { }.await() to withContext(ctx) { }.

这个问题与我关于Java中现有协程实现的问题有关.如果我怀疑,事实证明Java中目前没有完整的协同程序实现,那么实现它们需要什么？

正如我在那个问题中所说,我知道以下内容:

1. 您可以在后台实现"coroutines"作为线程/线程池.
2. 你可以在幕后用JVM字节码做一些棘手的事情,以使协同成为可能.
3. 所谓的"Da Vinci Machine"JVM实现具有原语,使得协程可以在没有字节码操作的情况下运行.
4. 协同程序也有各种基于JNI的方法.

我将依次解决每个人的不足之处.

基于线程的协同程序

这种"解决方案"是病态的.协同程序的重点是避免线程,锁定,内核调度等的开销.协同程序应该是轻量级的,并且只能在用户空间中执行.在具有严格限制的全倾斜螺纹方面实现它们可以消除所有优点.

JVM字节码操作

这种解决方案更实用,虽然有点难以实现.这与在C中的协同程序库中跳转到汇编语言大致相同(这是其中有多少工作),其优点是您只有一个架构可以担心并且正确.

它还将您绑定到仅在完全兼容的JVM堆栈上运行代码(例如,没有Android),除非您可以找到在非兼容堆栈上执行相同操作的方法.但是,如果您确实找到了这样做的方法,那么您现在已经将系统复杂性和测试需求翻了一番.

达芬奇机器

达芬奇机器很酷的实验,但由于它不是标准的JVM,它的功能无处不在.事实上,我怀疑大多数生产环境都会特别禁止使用达芬奇机器.因此,我可以使用它来进行很酷的实验,但不能用于我期望发布到现实世界的任何代码.

这也有类似于上面的JVM字节码操作解决方案的附加问题:将无法在替代堆栈(如Android)上工作.

JNI实施

这个解决方案在Java中实现这一点的意义重大.CPU和操作系统的每种组合都需要独立测试,每一种都是可能令人沮丧的微妙故障.或者,当然,我可以完全将自己绑定到一个平台,但这也使得用Java做事的意义完全没有实际意义.

所以...

有没有办法在不使用这四种技术之一的情况下在Java中实现协同程序？或者我会被迫使用那些闻起来最少的四个中的一个(JVM操作)？

编辑添加:

只是为了确保混乱载,这是一个相关的问题我的另外一个,但又不尽相同.那个人正在寻找一个现有的实施方案,以避免不必要地重新发明轮子.这是一个问题,如果另一个证明无法解决,将如何在Java中实现协同程序.目的是在不同的线程上保留不同的问题.

Android studio 报错：

Execution failed for task ':app:kaptDebugKotlin'.
> A failure occurred while executing org.jetbrains.kotlin.gradle.internal.KaptExecution
   > java.lang.reflect.InvocationTargetException (no error message)

我想在我的项目 Kotlin Coroutines 中添加并将其与 Room 数据库一起使用。但是在添加了所有库之后，我收到了这个错误。这是来自编译器的所有信息。

我已经确定，这是因为注释@Database。如果我删除此注释，则不会出现错误，但 Room 也无法正常工作。

我的gradle文件：

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
apply plugin: 'kotlin-kapt'
//apply plugin: 'androidx.navigation.safeargs'

kotlin {
    experimental {
        coroutines 'enable'
    }
}

android {
    compileSdkVersion 29
    defaultConfig {
        applicationId "com.bestcred.coursetthree"
        minSdkVersion 21
        targetSdkVersion 29
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        //vectorDrawables.useSupportLibrary = true
    }
    buildTypes {
        release {
            minifyEnabled …

我有一些关于Kotlin Flow 的问题