- 协程
- 如何使用协程？
- 1.启动协程的方式
- launch 启动一个协程，返回一个Job，可用来取消协程
- async 启动一个带返回结果的协程Deferred，通过Deferred.await()获取结果；
有异常并不会直接抛出，只会在调用 await 的时候抛出
- public interface Deferred : Job {}
- withContext 启动一个协程，传入CoroutineContext改变协程运行的上下文 - 2.协程运行的线程
- Dispatchers.Main -Android中的主线程
- Dispatchers.IO -针对磁盘和网络IO进行了优化，适合IO密集型的任务，比如：读写文件，操作数据库以及网络请求
- Dispatchers.Default -适合CPU密集型的任务，比如解析JSON文件，排序一个较大的list
- Dispatchers.Unconfined - 3.协程执行的函数或者方法使用suspend修饰
- 开启协程，示例代码：
fun main() {
val job = GlobalScope.launch { // launch a new coroutine and keep a reference to its Job
delay(1000L)
println("World!")
}
println("Hello,")
job.join() // wait until child coroutine completes
}- 协程的取消
- 调用cancel()或者job.cancelAndJoin()方法取消协程，运行中的协程任务并不会立即结束，需要配合Job的【isActive】属性判断。
- 正常情况下，父协程被取消，它的子协程都会被取消。
- 同一个CoroutineScope作用域取消了，其下面所有的子协程也会被取消
- 这种情况下，子协程不会被取消
try {
repeat(10) {
Log.d(TAG, "test: $it")
delay(500L)
}
} finally {
withContext(NonCancellable) {
Log.d(TAG, "test: withContext NonCancellable")
}
launch(NonCancellable) {
Log.d(TAG, "test: launch NonCancellable")
}
}
delay(1300L)
launch.cancel()
-------------------------------
结果如下：
test: 0
test: 1
test: 2
test: withContext NonCancellable
test: launch NonCancellable- 超时取消
- withTimeout(2000L) 取消失败会抛出异常信息：kotlinx.coroutines.TimeoutCancellationException
- withTimeoutOrNull(2000L) 取消失败会返回 null
- SupervisorJob —— Job是有父子关系的，如果存在多个子job，任一个子Job失败了，父Job也就会失败。
SupervisorJob是一个特殊的Job，里面的子Job不会相互影响，其中一个子Job失败了，不影响其他子Job的执行。 - 协程作用域？
- GlobalScope 单例的scope
public object GlobalScope : CoroutineScope {
/**
* Returns [EmptyCoroutineContext].
*/
override val coroutineContext: CoroutineContext
get() = EmptyCoroutineContext
}- MainScope()
@Suppress(“FunctionName”)
public fun MainScope(): CoroutineScope = ContextScope(SupervisorJob() + Dispatchers.Main)
作用域嵌套的情况，MainScope作用域下开启的协程不会被取消
val scope = GlobalScope.launch {
MainScope.async {
Log.d(TAG, "async。。。。")
}
}
scope.cancel()- 协程间数据同步
- 使用线程安全的数据类型，如：AtomicInteger。volatile在协程间不能保证数据的一致性
- Mutex 类似于线程中使用的 synchronized or ReentrantLock
- Mutex.withLock{ … }
public suspend inline fun <T> Mutex.withLock(owner: Any? = null, action: () -> T): T {
lock(owner)
try {
return action()
} finally {
unlock(owner)
}
}- actor 使用方法有点复杂
- 异常处理 CoroutineExceptionHandler
val handler = CoroutineExceptionHandler { _, exception ->
println("Caught $exception")
}
val job = GlobalScope.launch(handler) {
throw AssertionError()
}- java代码如何使用kotlin的协程？
- java中不能直接启动协程，需要在Kotlin类中使用协程，实现逻辑功能，然后在java代码中调用该类。
- 接口改造示例代码：
- ViewModel 基类 EasyVM.kt
val TAG: String? = EasyVM::class.java.canonicalName
abstract class EasyVM(application: Application) : AndroidViewModel(application) {
private val mainScope = MainScope()
fun launch(
context: CoroutineContext = Dispatchers.Main,
block: suspend CoroutineScope.() -> Unit
) =
mainScope.launch(context) {
try {
block()
} catch (e: Exception) {
Log.e(TAG, "[launch error info]:" + e.message)
}
}
/**
* viewmodel scope async
*/
suspend fun <T> async(
context: CoroutineContext = Dispatchers.Default,
block: suspend CoroutineScope.() -> T
) =
withContext(context) {
val result: T? = try {
block()
} catch (e: Exception) {
Log.e(TAG, "[async error info]:" + e.message)
null
}
result
}
override fun onCleared() {
super.onCleared()
mainScope.cancel()
}
}- 生成VM对象与之前相同。ViewModelProviders.of(this).get(VM.class);
- 简单封装retrofit网络库 EasyNet.kt
object EasyNet {
val EMPTY_CONFIG = NetConfig()
//全局默认配置
var gConfigMap = LinkedHashMap<String, NetConfig>()
inline fun <reified T> init(config: NetConfig = EMPTY_CONFIG) {
if (T::class.java.canonicalName?.isEmpty()!!) {
throw IllegalArgumentException("illegal argument T error !!!")
}
checkNonnull(config)
gConfigMap[T::class.java.canonicalName!!] = config
}
inline fun <reified T> create(config: NetConfig? = gConfigMap[T::class.java.canonicalName!!]): T {
config?.let {
checkNonnull(config)
return Retrofit.Builder()
.baseUrl(config.baseUrl)
.addConverterFactory(GsonConverterFactory.create(GsonBuilder().create()))
.client(providerClient(config))
.build()
.create(T::class.java)
}
throw IllegalArgumentException("illegal argument error:config must be init!")
}
fun providerClient(config: NetConfig): OkHttpClient =
OkHttpClient.Builder().apply {
addInterceptor(providerHeaderInterceptor(config))
addInterceptor(providerLogInterceptor(config))
config.interceptors.forEach { addInterceptor(it) }
config.dns?.let { dns(it) }
}.build()
private fun providerHeaderInterceptor(config: NetConfig): Interceptor = Interceptor { chain ->
val origin = chain.request()
val newBuilder = origin.newBuilder().headers(Headers.of(config.headers)).build()
chain.proceed(newBuilder)
}
private fun providerLogInterceptor(config: NetConfig): Interceptor =
HttpLoggingInterceptor().apply { level = config.logLevel }
fun checkNonnull(config: NetConfig) {
if (config.baseUrl.isEmpty()) {
throw IllegalArgumentException("illegal argument error:Expected baseUrl scheme 'http' or 'https' but no colon was found!!!")
}
}
}
class NetConfig {
/**
* 请求dns
*/
var dns: Dns? = null
/**
* 请求基地址
*/
var baseUrl = ""
/**
* 拦截器
*/
val interceptors = LinkedList<Interceptor>()
/**
* 头部参数
*/
val headers = LinkedHashMap<String, String>()
/**
* 网络请求日志level
*/
var logLevel = HttpLoggingInterceptor.Level.HEADERS
}- 协程的支持情况
- retrofit 2.6.0
- LiveData
- Room
- WorkManager - 协程优缺点
- 优点：
- 1.协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
- 2.单线程内就可以实现并发的效果，最大限度地利用cpu
- 3.可以按照同步思维写异步代码，即用同步的逻辑，写由协程调度的回调
- 缺点：
- 1.协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
- 2.协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程
注意事项：
- 1. runBlocking 是会阻塞主线程的，直到 runBlocking 内部全部子任务执行完毕。减少使用！！！