其他分享
首页 > 其他分享> > 协程再Android中的使用

协程再Android中的使用

作者：互联网

目录

协程的相关概念

协程是并发式的设计模式，简化异步执行。

协程的生命周期

协程的状态查询

常用的协程操作：

协程的上下文

Job Dispatchers CoroutineName都实现了Element接口，如果需要结合不同的CoroutineContext,可以通过plus来拼接。

Job 协程启动返回的对象，可以进行cancel join等操作，因为也是实现了CoroutineContext，一样可以用于启动协程的构造中。

var job: Job? = null

job = GlobalScope.launch(Dispatchers.Main) {
   LogUtils.w("执行在协程中...")
    delay(1000L)
    LogUtils.w("执行完毕...")
}

override fun onDestroy() {
    job?.cancel()
    super.onDestroy()
}

或者通过构造传入协程中
GlobalScope.launch(job.run { Job() }) {
    LogUtils.w("执行在协程中...")
    delay(1000L)
    LogUtils.w("执行完毕...")
}
override fun onDestroy() {
    job?.cancel()
    super.onDestroy()
}

var job: Job = Job()
GlobalScope.launch(job) {
    LogUtils.w("执行在协程中...")
    delay(1000L)
    LogUtils.w("执行完毕...")
}

override fun onDestroy() {
    job?.cancel()
    super.onDestroy()
}

Dispatchers 协程的调度

不管是指定协程的运行线程，还是临时切换线程，运行完毕会切换回来，都是通过 Dispatchers 来调度的。常用的线程调度为：

CoroutineName 可以成为协程命名

协程的作用域

GlobalScope，还有要一些常见的CoroutineScope对象

协程的管理

协程的启动

总结：async是异步执行，withContext是同步执行。
阻塞和非阻塞指是否阻塞其他协程。launch的是非阻塞的，runBlocking就是阻塞的，它会阻止其他协程的运行。runBlocking 会阻塞通协程域内的其他协程

GlobalScope.launch{
    val deferred = async{

    }
    val response = deferred.await()
    valr result = withContext(Dispatcher.IO){
        delay(1000L)
        return@withContext "1234"
    }
}
GlobalScope.launch{//主线程中调用
      LogUtils.w("执行在协程中...")
      //doSomeThing()
     GlobalScope.launch(Dispatchers.IO) {
        //异步执行
         LogUtils.w("异步执行result1")
         delay(1000L)
         LogUtils.w("result1:1234")
     }

     GlobalScope.launch(Dispatchers.IO) {//子线程中调用以下方法
        //异步执行
        LogUtils.w("异步执行result2")
        delay(1000L)
        LogUtils.w("result2:123456")
     }
     LogUtils.w("执行完毕...")
}
// 输出日志
执行在协程中
异步执行result1 
异步执行result2
执行完毕
result1:1234
result2:123456

异常管理

CoroutineExceptionHandler 协程异常处理

private val exceptionHandler = CoroutineExceptionHandler { _:CoroutineContext, throwable: Throwable->
    LogUtils.e(throwable.message ?: "Unkown Error")
}

 GlobalScope.launch(exceptionHandler) {
    doSomeThing()
}
增加扩展方法
fun CoroutineScope.safeLaunch(onError: ((Throwable) -> Unit)? = null,
    onBlock: () -> Unit) {
    val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
        one rror?.invoke(throwable)
    }

    this.launch(exceptionHandler) {
        onBlock.invoke()
    }
}

协程的常见使用和封装

launch(结果是先执行外部方法，再执行内部方法，非阻塞式) ，runBlocking(结果是先执行内部方法，再执行外部方法，阻塞式)， withContext ，async/await

sealed class Result<out T : Any> {
  data class Success<out T : Any>(val data: T? = null) : Result<T>()
  data class Error(val code: Int, val error: String) : Result<Nothing>()

  override fun toString(): String {
      return when (this) {
                is Success<*> -> "请求成功 -  data: $data"
                is Error -> "请求失败 - code:$code, error: $error"
            }
        }
    }
 suspend fun <T : Any> executeCal(call: suspend () -> Result<T>): Result<T> {
     return kotlin.runCatching { call() }.getOrElse { handleException(it) }
    }
 private fun handleException(e: Throwable): Result.Error {
     val error = when (e) {
        is CancellationException -> "请求取消"
        is SocketTimeoutException -> "连接超时"
        is JsonParseException -> "数据解析错误"
        is NumberFormatException -> "数据类型转换错误"
        else -> "请求失败，请稍后再试"
    }
    e.printStackTrace()
   return Result.Error(-1, error)
}

标签：协程,launch,LogUtils,线程,使用,Android,执行,GlobalScope
来源： https://www.cnblogs.com/alasola/p/16637415.html