用Coroutine替代AsyncTask

Bertha 。 2023-07-08 02:42 1阅读 0赞

使用Coroutine可以避免异步任务中的回调，首先想到的就是可以把AsyncTask给替换掉。废话少说，先看东西：

# AsyncTask #

--------------------

用AsyncTask实现的一段逻辑：点击Button后，TextView依次显示

Start -->  1 ... 10 --> end

class MainActivity : AppCompatActivity() { 
    
        override fun onCreate(savedInstanceState: Bundle?) { 
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
            button.setOnClickListener { 
                MyAsyncTask().execute()
            }
        }
    
        inner class MyAsyncTask : AsyncTask<Void, Int, Void>() { 
    
            override fun onPreExecute() { 
                text.setText("Start")
                Thread.sleep(800)
            }
    
            override fun doInBackground(vararg param: Void?): Void? { 
                for (i in 1..10) { 
                    publishProgress(i)
                    Thread.sleep(800)
                }
                return null
            }
    
            override fun onProgressUpdate(vararg values: Int?) { 
                text.setText(values[0].toString())
            }
    
            override fun onPostExecute(result: Void?) { 
                text.setText("Finish")
            }
        	
        	override fun onCancelled() { 
                Log.e(localClassName, "Cancelled")
        	}
    
        }
    }

一个简单的异步任务要实现四个回调，实在不优雅。

# Coroutine #

--------------------

同样的需求用Coroutine实现如下：

class MainActivity : AppCompatActivity() { 
    
        val scope = CoroutineScope(Dispatchers.Default)
    
        override fun onCreate(savedInstanceState: Bundle?) { 
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
        }
    
        override fun onResume() { 
            super.onResume()
            button.setOnClickListener { 
                scope.launch { 
                    myTask()
                }
            }
        }
    
        override fun onPause() { 
            super.onPause()
            scope.coroutineContext.cancel()
        }
    
    
        private suspend fun myTask() { 
            try { 
                // 相当于onPreExecute，withContext可以在切换线程的同时进行线程同步
                withContext(Dispatchers.Main) { 
                   text.text = "Start"
                }
    
                // 相当于doInBackground
                Thread.sleep(800)
                for (i in 1..10) { 
                    //相当于onProgressUpdate
                    withContext(Dispatchers.Main) { 
                        text.text = i.toString()
                    }
                    Thread.sleep(800)
                }
    
                // 相当于onPostExecute
                withContext(Dispatchers.Main) { 
                    text.text = "Finish"
                }
            } catch (e: Exception) { 
                // 相当于onCancelled
                Log.e(localClassName, "Cancelled", e)
            }
        }
    }

一气呵成，困扰我多年的便秘终于被治好了。

# CoroutineScope #

--------------------

Coroutine版本的代码中Activity中多了针对CoroutineScope的处理。CoroutineScope是Coroutine运行的基础，它提供了创建并启动Coroutine的常用方法，例如我们常用的`launch`、`async`等，虽然是扩展方法。  
每个CoroutineScope管理一个CoroutineContext，通过`launch`或者`async`启动协程会返回一个句柄Job存放在CoroutineContext进行管理。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpdGF2aXZh_size_16_color_FFFFFF_t_70]

### CoroutineDispatcher ###

val scope = CoroutineScope(Dispatchers.Default)

`CoroutineScope`创建时可以通过`CoroutineDispatcher`指定其被派发到哪个线程执行，`CoroutineDispatcher`其实也是`CoroutineContext`的子类。

<table> 
 <thead> 
  <tr> 
   <th align="left">CoroutineDispatchers</th> 
   <th align="left">Description</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Dispatchers.Main</td> 
   <td align="left">MainThread中执行</td> 
  </tr> 
  <tr> 
   <td align="left">Dispatchers.Default</td> 
   <td align="left">使用CommonPool执行，共享一个后台线程池</td> 
  </tr> 
  <tr> 
   <td align="left">Dispatchers.IO</td> 
   <td align="left">启动新线程执行</td> 
  </tr> 
  <tr> 
   <td align="left">Dispatchers.Unconfined</td> 
   <td align="left">无指定派发线程, 有可能在任意线程派发，要根据运行时的CoroutineContext决定，因为有不确定性不推荐使用</td> 
  </tr> 
 </tbody> 
</table>

### Cancel ###

在生命周期结束时，执行了以下代码

scope.coroutineContext.cancel()

调用CoroutineContext的`cancel()`后，内部所有的Job都会被结束，从而有效避免内存泄漏。这与AsyncTask的cancel类似，但是现在有了一个几种cancel的地方，不需要一个一个单独调用cancel了。  
Coroutine被cancel后内部会抛出`JobCancellationException`，可以通过try…catch捕捉并实现异常处理。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpdGF2aXZh_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020022417532363.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpdGF2aXZh,size_16,color_FFFFFF,t_70