一 挂起

suspend代表挂起，从当前线程挂起，换句话说，就是这个协程从执行他的线程上脱离
看下以下代码：

viewModelScope.launch {
    val resp = repo.uploadOss(bitmap)
    Log.d("", resp.toString())
}

  suspend inline fun uploadOss(bitmap : Bitmap) : NetResult<OssBean> {
        return withContext(Dispatchers.IO) {
            ...
        }
}

这段代码是指的往你的主线程post一个Runnable，这个Runnable就是你的协程代码：

handler.post {
    val resp = repo.uploadOss(bitmap)
    Log.d("", resp.toString())
}

执行在哪个线程

我们来看以下两段代码：

 viewModelScope.launch {
            startLoading()
            LogUtils.d("", "thread launch:${Thread.currentThread().name}" )
            val data = repo.requestHttp()
            endLoading()
}

fun requestHttp() : Response {
          LogUtils.d("", "thread suspend:${Thread.currentThread().name}" )
         val response = call()
          return response
}

打印出来：

thread launch:main @coroutine#1
thread suspend:main @coroutine#1

main: 表示这个协程的名称或入口函数是 main。
@coroutine#1: 表示这是第一个协程实例，#1 是一个标识符，用于区分不同的协程实例。
将代码稍微修改下：

fun requestHttp() : Response {
       val response = withContext(Dispatchers.IO) {
            LogUtils.d("fjb", "thread suspend:${Thread.currentThread().name}" )
            call()
        }
    return response
}

打印出来：

thread launch:main @coroutine#1
thread suspend:DefaultDispatcher-worker-1 @coroutine#1

所以，suspend并没有切换线程，真正切换线程需要withContext

挂起函数在执行完成之后，协程会重新切回它原先的线程。

协程又是如何切换回来的

它通过一个叫 Continuation 的接口的实例来返回结果：

public interface Continuation<in T> {
 public val context: CoroutineContext
 public fun resumeWith(result: Result<T>)
}

举例，以下代码：

GlobalScope.launch(Dispatchers.Main) {
 try {
 //showUser 在 await 的 Continuation 的回调函数调用后执行
 showUser(api.getUser().await())
 } catch (e: Exception) {
 showError(e)
 }

await方法定义：

public suspend fun await(): T

但在虚拟机里，他的真实签名是：

kotlinx/coroutines/Deferred.await (Lkotlin/coroutines/Continuation;)Ljava/lang/Object;

以上例子代码相当于:

//注意以下不是正确的代码，仅供大家理解协程使用
GlobalScope.launch(Dispatchers.Main) {
    api.getUser().await(object: Continuation<User>{
 override fun resume(value: User) {
 showUser(value)
 }
 override fun resumeWithException(exception: Throwable){
 showError(exception)
 }
 })
}

await相当于如下实现：

fun await(continuation: Continuation<User>): Any {
 try {
 val user = ...
 handler.post{ continuation.resume(user) }
 } catch(e: Exception) {
 handler.post{ continuation.resumeWithException(e) }
 }
}

二。使用时机

协程中有luanch和async两个函数
我们来看下以下两种获取网络结果的方式：

第一种

viewModelScope.launch {
    startLoading()
    val resp = repo.uploadOss(bitmap)
    Log.d("", resp.toString())
    endLoading
}

第二种

viewModelScope.launch {
    startLoading()
    val def: Deferred<NetResult<OssBean>> = async {
        repo.uploadOss(bitmap)
    }
    Log.d("", def.await().toString())
  endLoading
}

第一种：
调用 repo.uploadOss(bitmap) 时，协程会挂起，直到该函数完成并返回结果。然后，结果会被赋值给resp变量，并打印到日志中。
第二种：
async 会启动一个新的协程并返回一个 Deferred 对象。Deferred对象代表一个将来会返回结果的任务。通过调用 def.await()，当前协程会挂起，直到 async 块中的任务完成并返回结果。然后，结果会被打印到日志中。

结论：
在大多数情况下，两种方式的效果是相同的，但 async 方式更适合需要并行执行多个异步任务的场景，因为它可以启动多个并行任务并等待它们的结果。
比如：

viewModelScope.launch {
    startLoading()
    val def: Deferred<NetResult<OssBean>> = async {
        repo.uploadOss(bitmap)
    }
   val count: Deferred<NetResult<Int>> = async {
        repo.countOss()
    }
    Log.d("", "上传结果${def.await().toString()}, 现在一共有${count.await().toString()}")
  endLoading
}