一、如何使用协程
1.1 添加依赖
implementation
'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.0.0'
implementation
'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.0.0'
1.2 使用协程Coroutine
在kotlinx.coroutines包中，你可以使用launch或async启动一个协程。从概念上讲，async就像launch一样，它启动一个单独的协程，协程相当于一个轻量级的线程，与其他所有的协同程序同时工作。
async和launch不同的地方在于，launch返回一个Job并且不携带任何结果值，而async返回Deffered。
Deffered表示一个轻量级的非阻塞未来，表示稍后提供结果的承诺。我们可以使用await()方法获取一个deffered的返回结果。Deffered本质上也是Job，因此可以在需要的时候取消它。
如果在launch中的代码因为异常而终止，那么它会被是为线程中未捕获异常而导致应用崩溃。异步代码中未捕获异常存储在生成的Deffered中，并且不会在其他任何地方传递，除非经过处理，否则它会被静默删除。
协程分发
在Android中，我们常用的又两个分发器dispatcher：
uiDispatcher：将执行分发到Android主UI线程(用于父协程)
bgDispatcher：在后台线程中调度执行(用于子协程)
// dispatches execution into Android main thread
val uiDispatcher: CoroutineDispatcher = Dispatcher.Main
// represent a pool of shared thread as coroutine dispatcher
val bgDispatcher: CoroutineDispatcher = Dispatcher.IO
协程作用域
使用协程需要提供协程对应的作用域CoroutineScope或使用GlobalScope
// GlobalScope示例
class MainFragment : Fragment(){
fun loadData() = GlobalScope.launch{...}
}
//CoroutineScope示例
class MainFragment : Fragment(){
val uiScope = CoroutineScope(Dispatchers.Main)
fun loadData() = uiScope.launch{...}
}
//Fragment实现CoroutineScope示例
class MainFragment : Fragment(),CoroutineScope{
override val coroutineContext: CoroutineContext
get() = Dispatcher.Main
fun loadData() = launch {...}
}
lauch+async(执行任务)
父协程通过Main Dispatcher调用的launch方法启动。
子协程通过IO Dispatcher调用async方法启动。
Note：父协程会一直等待它的子协程完成
Note：协程如果发生未捕获异常，程序会崩溃
val uiScope = CoroutineScope(Dispatchers.Main)
fun loadData() = uiScope.launch {
view.showLoading() //ui thread
val task = async(bgDispatcher){ //background thread
// your blocking call
}
val result = task.await()
view.showDta()
}
lauch+withContext(执行任务)
使用上一个例子中的方法，我们可以正常的运行。但我们浪费了启用第二个后台任务协程的资源。
如果我们只启用一个协程，可以使用withContext来优化我们的代码。
后台任务通过带有IO Dispatcher的withContext函数执行。
val uiScope = CoroutineScope(Dispatcher.Main)
fun loadData() = uiScope.launch {
view.showLoading() //ui thread
val result = withContext(bgDispatcher){
// your blocking call
}
view.showData(result) // ui thread
}
launch+ withContext(按顺序执行两个任务)
val uiScope = CoroutineScope(Dispatchers.Main)
fun loadData() = uiScope.launch {
view.showLoading() // ui thread
val result1 = withContext(bgDispatcher){
// your blocking call
}
val result2 = withContext(bgDispatcher){
//your blocking call
}
val result = result1 + result2
vuew,showData(result) //ui thread
}
launch+async+async(并行执行两个任务)
val uiScope = CoroutineScope(Dispatcher.Main)
fun loadData() = uiScope.launch {
view.showLoading() // ui thread
val task1 = async(bgDispatcher){
//your blocking call
}
val task2 = async(bgDispatcher){
//your blocking call
}
val result = task1.await() + task2.await()
view.showData() // ui thread
}
二、如何使用协程的timeout
如果我们想为一个协程任务设置超时，我们可以使用withTimeoutOrNull()方法，如果超时就返回null。
val uiScope = CoroutineScope(Dispatchers.Main)
fun loadData() = uiScope.launch {
view.showLoading() // ui thread
val task = async(bgDispatcher){
//your blocking call
}
// suspend until task is finished or return null in 2s
val result = withTimeoutOrNull(2000) { task.await() }
view.showData(result) // ui thread
}
三、如何取消一个协程
3.1 job
loadData()方法返回一个Job对象，Job对象是可以被取消的。当父协程被取消的时候，它的所有子协程都会被结束。当stopPresenting()方法被调用，view.showData()肯定不会被调用。
val uiScope = CoroutineScope(Dispatchers.Main)
val job: Job? = null
fun startPresenting(){
job = loadData()
}
fun stopPresenting(){
job?.cancel()
}
fun loadData() = uiScope.launch {
view.showLoading() // ui thread
val result = withContext(bgDispatcher){
// your blocking call
}
view.showData(result) //ui thread
}
3.2 parent job
取消协程的另一种方法是创建SupervisorJob对象，并通过重载+运算符在作用域构造函数中指定它。
var job = SipervisorJob()
val uiScope = CoroutineScope(Dispatchers.Main + job)
fun startPresenting(){
loadData()
}
fun stopPresenting(){
scope.coroutineContext.cancelChildren()
}
fun loadData() = uiScope.launch {
view.showLoading()
val result = withContext(bgDispatcher) {
// your blocking call
}
view.showData(result)
}
3.3 自定义具有生命周期感知的协程作用域
class MainScope : CoroutineScope, LifecycleObsever {
private val job = SupervisorJob()
override val coroutineContext: CoroutineContext
get() = job + Dispatchers.Main
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun destory() = coroutineContext.cancelChildren()
}
//使用
class MainFragment : Fragment(){
private val uiScope = MainScope()
override fun onCreate(savedInstanceState: Bundle?){
super.onCreate(savedInstanceState)
lifecycle.addObserver(mainScope)
}
private fun loadData() = uiScope.launch {
val result = withContext(bgDispatcher) {
// your blocking call
}
}
}
下面，举一个在ViewModel中使用生命周期感知的协程。
open class ScopedViewModel : ViewModel(){
private val job = SupervisorJob()
protected val uiScope = CoroutineScope(Dispathcers.Main + job)
override fun onCleared(){
super.onCleared()
uiScope.coroutineContext.cancelChildren()
}
}
//使用
class MyViewModel : ScopedViewModel(){
private fun loadData() = uiScope.launch {
val result = withContext(bgDispatcher) {
// your blocking call
}
}
}
四、如何处理协程中的异常
4.1 try-catch
我们可以使用try-catcher捕获并处理异常
private fun loadData() = GlobalScope.launch(uiDispatcher) {
view.showLoading()
try {
val result = withContext(bgDispatcher) { dataProvider.loadData() }
view.showData(result)
} catch(e: Exception){
e.printStackTrace()
}
}
为了避免在Presenter中使用try-catch，最好在dataProvider.loadData()函数中处理异常并使其返回通用Result类。
data class Result(val success: T? = null,
val error: Throwable? = null)
private fun loadData() = launch(uiContext){
view.showLoading()
val task = async(bgContext) { dataProvider.loadData("Task") }
val result: Result = task.await()
if(result.success != null){
view.showData(result.success)
} else if(result.error != null){
result.error.printStackTrace()
}
}
4.2 async parent
使用async启动父协程来忽视异常。
private fun loadData() = GlobalScope.async(uiDispatcher) {
view.showLoading()
val result = withContext(bgDispatcher) { dataProvider.loadData() }
view.showData(result)
}
使用这种方法， 异常会被保存在job对象中。我们可以使用invokeOnCompletion()方法来取回它。
var job: Job? = null
fun startPresenting() {
job = loadData()
job?.invokeOnCompletion { it: Throwable? ->
it?.printStackTrace()
job?.getCompletionException()?.printStackTrace()
}
4.3 launch + coroutine exception handler
你可以将CoroutineExceptionHandler添加到父协同程序上下文以捕获异常并处理它们。
val exceptionHandler: CoroutineContext = CoroutineExceptionHandler {
-, throwable->
view.showData(throwable.message)
job = Job()
}
private fun loadData() = GlobalScope.async(uiDispatcher + exceptionHandler){
view.showLoading()
val result = withContext(bgDispatcher) { dataProvider.loadData() }
view.showData(result) //如果发生异常就不会被调用
}
五、如何测试协程
启动一个协程需要你指定一个CoroutineDispatcher。
class MainPresenter(val view: MainView,
val dataProvider: DataProviderAPI) {
private fun loadData() = GlobalScope.launch(Dispacthers.Main){
view.showLoading()
val result = withContetx(Dispatchers.IO) { dataProvider.loadData() }
view.showData(result)
}
}
如果你想为上面的MainPresenter编写一个单元测试，你可能需要指定一个协程context用于ui和background执行。
可能最简单的方法是向MainPresenter构造函数添加两个参数：uiDispatcher，默认值为Main，ioContext，默认值为IO。
class MainPresnter(val view: MainView,
val dataProvider: DataProviderAPI,
val uiDispatcher: CoroutineDispatcher = UI,
val ioDispatcher: CoroutineDispatcher = IO){
private fun loadData() = GlobalScope.launch(uiDispatcher) {
view.showLoading()
val result = withContext(ioDispatcher) { dataProvider.loadData() }
view.showData(result)
}
}
现在，您可以通过提供Unconfined来轻松测试您的MainPresenter类，它只会在当前线程上执行代码。
@Test
fun startPresenting(){
//given
val view = mock(MainView::class.java)
val dataProvider = mock(DataProviderAPI::class.java)
val presenter = MainPresenter(view,
dataProvider,
Dispatcher.Unconfined,
Dispacther.Unconfined)
//when
presenter.startPresenting()
//then
}
六、如何实现协程线程日志
要了解哪个协同程序执行当前工作，可以通过System.setProperty打开调试工具并通过Thread.currentThread().name来记录线程名称。
//调式模式
System.setProperty("kotlinx.coroutines.debug", if(BuildConfig.DEBUG) "on" else "off")
launch(UI) {
log("Data loading started")
val task1 = async { log("Hello") }
val task2 = async { log("World") }
val result = task1.await() + task2.await()
log("Data loading completed: $result")
}
fun log(msg: String){
Log.d(TAG， "[${Thread.currentThread().name}] $msg")
}