I. marco de conmutación corrutina (corrutina) Kotlin hilo

Aplicaciones típicas:

Abrir una co-rutina, el contexto CoroutineContex corrutina designado (que comprende un hilo de la agrupación de hebras y similares)
que comprende además un co-rutina interna (esta operación menos), la función de pendiente (más), el código de operación multiproceso (más) y similares;
función que cuelga experiencia, que entrará en función de las roscas del interruptor de suspender hilo función especificada, y después de la aplicación, a continuación, volver a cortar el hilo original para continuar.

II. Suspender la función suspender la diversión

función de suspender, corrutina colgar; hang, en lugar de bloquear.
El uso más directo es en el hilo principal, se encontró con una función de pendiente, ir a la ejecución en espera dentro de una función;

Si la función de suspensión, una co-rutina ha sido designado como un hilo, el hilo se cambiará la operación;
sin tener en cuenta el corte no corta el hilo, suspender la función se ha completado, se continúa hacia abajo.
Sin embargo, si se trata de cortar el hilo designado por la co-rutina a un niño, entonces no se aplicará plenamente hasta que se termine el hilo. (Tal como el uso de Thread, ThreadPoolExecutorpara iniciar el hilo)

descompilar ver, la función de empaquetado como suspender Continuationobjetos, por Continuation#resumeWith(result:Result<T>)la obtención de los resultados, result.isFailure/isSuccesssuspender fallo de la función / éxito, para obtener el resultado de la función externa pendiente después de nuevo después de la ejecución.

Suspender sí mismo no puede hacer que la función está suspendido. Su uso en combinación con co-rutina, o en otra pendiente de la función para realizar operaciones de suspensión.
función de suspender, requiere un co-rutina se suspende o otra llamada a la función, el objetivo final, o para ser ejecutado corrutina.

suspend fun m() {
	//withContext 是一个挂起函数
	withContext(Dispatchers.IO) {
		...
	}
}

Una vez corrutina retenida función suspender (no necesariamente de conmutación de hilos) será suspendido código corrutina no corre hacia abajo hasta función ejecutada suspender.

withContext (), Kotlin proporciona una función de suspensión:

public suspend fun <T> withContext(
		context: kotlin.coroutines.CoroutineContext, 
		block: suspend kotlinx.coroutines.CoroutineScope.() -> T
	) : T {   }

III. La creación de corrutina

a. CoroutineScope alcance corrutina

La creación de CoroutineScope:

runBlocking()Bloqueo. Va a esperar hasta que todos los sub corrutina interna con pendientes de ejecución de la función se ha completado. Interior crea BlockingCoroutineel bloqueo de objetos co-rutina
MainScope()No existe una implementación de la biblioteca estándar específico (escribe una demostración de la consola se quejan). Android está allí. El hilo principal del alcance co-rutina.
GlobalScopeUna clase de objeto. ámbito global. No se cancelará el nivel alcance padre no global y cancelado.
implementación personalizada

class MyCoroutineScope(
		override val coroutineContext: CoroutineContext
	) : CoroutineScope

CoroutineScope Funciones ampliadas:

launch()No bloqueante. El valor por defecto depende CoroutineContext CoroutineScope. Volver al trabajo. StandaloneCoroutine interior crea un objeto (que implementa el Trabajo, Continuación, CoroutineScope).
async()No bloqueante. Se crea una nueva CoroutineContext. Interna crear objetos DeferredCoroutine (que diferida, Trabajo, Continuación, CoroutineScope DefaultDispatcher)

si. lanzamiento()

public fun kotlinx.coroutines.CoroutineScope.launch(
		context: kotlin.coroutines.CoroutineContext, 
		start: kotlinx.coroutines.CoroutineStart, 
		block: suspend kotlinx.coroutines.CoroutineScope.() -> kotlin.Unit
	) : kotlinx.coroutines.Job {  }

Acerca de los parámetros:
context: contexto corrutina CoroutineContext
start: Modo de inicio corrutina CoroutineStart
block: a, CoroutineScope, función de extensión anónima suspendido. Por la función interna coroutineScope(block){}para crear un CoroutineScopeobjeto alcance co-rutina.
Nota: La función CoroutineScope () lo mismo que la declaración extendida, pero no un nombre de función. Sin embargo, a través de pruebas encontró, bloqueo de llamadas, de hecho, es la necesidad de pasar un objeto CoroutineScope, por lo que cuando se llama al bloque de función se crea objeto CoroutineScope.
Escribí ejemplo,

fun test(v: Int, block: Int.()  -> Double) {
   println(block(v * 2)) //println 2048.0
}
fun calc(a: Int): Double {
   return (a shl 10) * 1.0 //2<<10 = 2048
}
test(1) {
   calc(this)
   //18.5
}

prueba de llamadas (), pasando un parámetro int, y una función;; es decir, {calc (esto)} Esta es toda un bloque de parámetros de prueba
aplicación test (), el valor de retorno bloque de impresión (); requiere un Int forma de bloque parámetro, donde V se multiplica a 2;
Bloquear <==> {calc (el este)}, en este momento esta = 2, la función se obtiene después calc 2048,0;
Finalmente, bloquear el valor de retorno se 2048,0 println () a cabo si las notas el "18,5" declaración abierta, que es bloquear el valor de retorno () de. gramática Kotlin, donde los resultados durarán línea de código como valor de retorno.

C. asíncrono ()

public fun <T> kotlinx.coroutines.CoroutineScope.async(
		context: kotlin.coroutines.CoroutineContext, 
		start: kotlinx.coroutines.CoroutineStart, 
		block: suspend kotlinx.coroutines.CoroutineScope.() -> T
	): kotlinx.coroutines.Deferred<T> { }

re. runBlocking ()

public fun <T> runBlocking(
		context: kotlin.coroutines.CoroutineContext,  
		block: suspend kotlinx.coroutines.CoroutineScope.() -> T
	): T {  }

Estas funciones de la cuenta, el contexto, comienzan todos reciben un valor dado.
Contexto: CoroutineContext = EmptyCoroutineContext,
inicio: CoroutineStart = CoroutineStart.DEFAULT,

e. modo de inicio corrutina CoroutineStart

public enum class CoroutineStart {
    DEFAULT, 						//默认的模式，立即执行协程体
    LAZY,							//只有在需要的情况下运行
    @ExperimentalCoroutinesApi		//实验性 协程 api
    ATOMIC,							//
    @ExperimentalCoroutinesApi
    UNDISPATCHED;					//
}

F. Trabajo

Las principales funciones miembro:

jon()corrutina espera ejecutado. (Tema similar # join ())
cancel()Cancelar corrutina. Corrutina todas las funciones pendientes son cancelables. Ellos cheques cancelados corrutina, y los tiros en CancellationException cancelado.
cancelAndJoin()En el interior es el primer Cancelar () y luego se unen (). Espere a que la cancelación completa

sol. Diferido

Es un sub-interfaz de Job. Hay una await().
await()Es una función de suspensión, tiene un tipo de retorno <T>.
Llama, se suspenderá corrutina, después de la aplicación para obtener un resultado T.

h. planificador despachadores

Lograr la auto CoroutineContext.

public actual object Dispatchers {
	public actual val Default: CoroutineDispatcher = createDefaultDispatcher()
	public actual val Main: MainCoroutineDispatcher get() = 
			MainDispatcherLoader.dispatcher
	public actual val Unconfined: CoroutineDispatcher = 
			kotlinx.coroutines.Unconfined
	public val IO: CoroutineDispatcher = DefaultScheduler.IO
}

Principal Andrews en el uso de energía que el hilo de interfaz de usuario; la consola no se puede utilizar, no se ha implementado.
Un grupo de subprocesos despachador IO rosca interior; la realización de un disco o de red I / O-intensiva;
una piscina rosca interna hilo despachador predeterminadas, efectúe intensivo de la CPU;
no confinado sin restricciones

i. Otras funciones Suspender

delay()Cuántos milisegundos corrutina se suspende. (Thread.sleep similares ())
yield()Si es posible, la corriente despachadores co-rutina hilo (o un grupo de subprocesos) a disposición de otros programas de cooperación. (Thread.yield similares ()). El siguiente ejemplo, se emitirá intercalada:

// 同是 Main、Default、Unconfined，才会在 yield 切换运行的协程时，在同一线程中。
// IO 会创建新线程。 Default 内部是一个线程池。
runBlocking {
    launch(Dispatchers.Unconfined, CoroutineStart.LAZY) {
        for (i in 0..3) {
            println("aaaa ${Thread.currentThread().name}")
            yield()
        }
    }
    launch(Dispatchers.Unconfined, CoroutineStart.LAZY) {
        for (i in 0..3) {
            println("bbbb  ${Thread.currentThread().name}")
            yield()
        }
    }
}

IV. Proceso Uso

En primer lugar crear alcance corrutina (al mismo tiempo, se creará un co-rutina interna)
alcance Coroutine, además del código ordinario y pueden contener otros co-rutina función suspender (por supuesto, puede haber más sub-co-rutina suspender la función)
Puede especificar CoroutineContext, despachadores, CoroutineStart
Necesidad de ser co-rutina se unen, cancelar la operación, o para esperar los resultados; lanuch utilizado con el fin de seleccionar () o la asíncrono ();
Diferida es una subclase de empleo también se unen, cancelar la operación, la cual
withContext es una función de pendiente. Para usarlo, es decir, no importa corrutina unen, cancelar la operación Await