骑着家雀吃辣条
骑着家雀吃辣条

2020-03-19 Android Kotlin Coroutines 延时处理

I. 引入Coroutines

首先，Coroutines是一个单独的包，如果你是普通Java开发者，建议使用官方的教程进行引入，如果你和我一样是Android开发者，建议直接使用Anko-Coroutines):


本文所有案例均在kotlin 1.1.4与kotlinx-coroutines-core 0.18版本进行实验(由于我引入anko时，anko引用的coroutines时0.15版本因此这里引入0.18版本进行替换(至于为什么高版本会自动替换低版本可以参考这篇文章))。

从kotlin 1.3起，coroutine已经进入了1.0并且不再是experimental了，相关引入如下, 我们直接参照kotlinx.coroutines中，进行引入:

implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.0.1"

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.0.1'

简单案例

我们使用kotlin 1.0.1版本做一个简单的案例，案例中我们在主线程中异步的执行一个耗时操作，然后再在最后弹一个Toast:

首先引入上面提到的kotlinx-coroutines-core与kotlinx-coroutines-android 两个依赖，然后在MainActivity中:

class MainActivity : AppCompatActivity() {  

override fun onCreate(savedInstanceState: Bundle?){   

 super.onCreate(savedInstanceState)    ...    

GlobalScope.launch(Dispatchers.Main) {      

async(Dispatchers.IO) { delay(5000) }.await()     

 Toast.makeText(this@MainActivity, "finish async job but not block main thread", Toast.LENGTH_LONG).show()   

 }

  }

}

II. 什么是Kotlin Coroutines

Coroutines中文名”协程”，简单来说就是使用suspend来代替线程阻塞，可以理解为无阻塞的异步编写方式，基本原理是使用更轻的协程来代替繁重的阻塞操作(为什么阻塞是繁重的，可以参考这篇文章)，并且复用原本阻塞的线程资源。

综合C#、Lua等中的Coroutine对于suspend的翻译，文中为了便于理解，将suspend的操作(如delay)称为”挂起”。kotlin协程的挂起是十分廉价的，相反的线程的阻塞是十分昂贵的。

协程中每个coroutine都是运行在对应的CoroutineContext中的，为了便于理解，文中将CoroutineContext称为”coroutine上下文”。而coroutine上下文可以是为coroutine提供运行线程的CoroutineDispatcher(如newSingleThreadContext创建的单线程coroutine上下文、CommonPool公共的拥有与CPU核实相当线程数的线程池等)，可以是用于管理coroutine的Job、甚至可以是继承自Job的可以为异步任务带回数返回值的的Deferred等。

Kotlin协程的特征

我们知道协程的概念并不是kotlin第一个提出的，在此之前已经有很多语言有协程的概念，但是kotlin协程有自己的特征:

[if !supportLists]1. [endif]koltin的协程完全是通过编译实现的(不愧是IDE公司出的^ ^)，没有修改JVM或者是底层逻辑

[if !supportLists]2. [endif]相比其他语言的协程，kotlin的协程可谓非常的全面，其不仅支持C#和ECMAScript的async/await、Go的channels与select，还支持C#和Python的build sequence/yield等

本质

本质上，协程是在在用户态直接对线程进行管理，不同于线程池，协程进一步的管理了不同协程切换的上下文，协程间通讯，协程的挂起，相对于线程而言，协程更轻；在并行逻辑的发展进阶过程中，可以理解为进程->线程->协程。

下图我根据源码理解画的kotlin协程中对挂起的基本实现:

带来的好处

[if !supportLists]1. [endif]通过协程我们可以很简单的使用async来让原本需要使用异步+回调的编写方式，可以通过看似同步的编写方式写代码

[if !supportLists]2. [endif]提供多种线程间通信的方式，如channel，以及延伸出的producer、pipeline等

[if !supportLists]3. [endif]在多协程（原本的线程）管理方面更加灵活，如通过多个协程绑定同一job进行全局管控

[if !supportLists]4. [endif]减少了所需要的线程数，由于使用协程的概念在用户态接管线程，完成各协程的调配，通过挂起代替阻塞，有效利用闲置的线程资源。

可能带来的问题

[if !supportLists]1. [endif]目前kotlin协程还处在试验期

[if !supportLists]2. [endif]生搬硬套会使得代码更加复杂

[if !supportLists]3. [endif]在一些场景上使用协程使得反复利用使用同一个线程，反而多核处理器的优势无法发挥

需要注意

我们可以通过目前kotlinx.coroutines所在包名(kotlin.coroutines.experimental)获知目前kotlin协程还是实验性的，并且根据官方文档，等到完全设计完成后最终API会移到kotlin.coroutines中，正因为这个原因，官方建议给基于协程API的包添加experimental后缀(如:cn.dreamtobe.experimental)，等到最终发布后，再迁移到无experimental后缀的包中，并且官方表明会做兼容以最小化迁移成本。

III. 挂起是很轻的操作

我测试了如下两个代码(不过其实这块代码是一个极端情况，并且是体现挂起优势的代码):

// 使用协程

println("Coroutines: start")val jobs = List(100_000) {   

 // 创建新的coroutine    launch(CommonPool) {        // 挂起当前上下文而非阻塞1000ms        delay(1000L)        println("." + Thread.currentThread().name)    }}jobs.forEach { it.join() }println("Coroutines: end")println("No Coroutines: start")// 使用阻塞val noCoroutinesJobs = List(100_000) {    // 创建新的线程    thread {        // 阻塞        Thread.sleep(1000L)        println("." + Thread.currentThread().name)    }}noCoroutinesJobs.forEach { it.join() }println("No Coroutines: end")

在Nexus6P上：使用协程的大约在8s左右完成所有输出；而不使用协程的大约2min才完成所有输出


这里你可能会提出，这里很大程度是复用了线程?

是的，这就是协程的特性，使用挂起当前上下文替代阻塞，使得可以复用被delay的线程，大量减少了这块的资源浪费。

而使用阻塞的情况是，不断创建新的线程然后阻塞，因此哪怕是我们使用线程池，也无法复用其中的任何线程，由于这里所有的线程都被阻塞了。如果这块不明白，可以直接使用以下的代码，让阻塞的测试用例也跑在一个尽可能提供线程复用的常规线程池中，结果相同大约2min才完成所有输出:

val noCoroutinesPool: ExecutorService = Executors.newCachedThreadPool()println("No Coroutines: start")// 使用阻塞val noCoroutinesJobs = List(100_000) {    Executors.callable {        Thread.sleep(1000L)        println("thread." + Thread.currentThread().name)    }}noCoroutinesPool.invokeAll(noCoroutinesJobs)println("No Coroutines: end")

IV. 如何使用协程

[if !supportLists]o [endif]run(CoroutineContext) { ... }: 创建一个运行在CoroutineContext制定线程中的区块，效果是运行在CoroutineContext线程中并且挂起父coroutine上下文直到区块执行完毕

[if !supportLists]o [endif]runBlocking(CoroutineContext) { ... }: 创建一个coroutine并且阻塞当前线程直到区块执行完毕，这个一般是用于桥接一般的阻塞试编程方式到coroutine编程方式的，不应该在已经是coroutine的地方使用

[if !supportLists]o [endif]launch(CoroutineContext) { ... }: 创建运行在CoroutineContext中的coroutine，返回的Job支持取消、启动等操作，不会挂起父coroutine上下文；可以在非coroutine中调用

[if !supportLists]o [endif]suspend fun methodName() { ... }: 申明一个suspend方法，suspend方法中能够调用如delay这些coroutine特有的非阻塞方法；需要注意的是suspend方法只能在coroutine中执行

[if !supportLists]o [endif]async(CoroutineContext) { ... }: 创建运行在CoroutineContext中的coroutine，并且带回返回值(返回的是Deferred，我们可以通过await等方式获得返回值)

1. fun methodName(...) = runBlocking { ... }

申明methodName方法是顶层主协程方法。一般是用于桥接一般的阻塞试编程方式到coroutine编程方式的，不应该在已经是coroutine的地方使用。

fun main(args: Array) = runBlocking {    val job = launch(CommonPool) {        // 挂起1000ms        delay(1000L)    }    // 接口含义同Thread.join只是这里是`suspension`    job.join()}// 编译失败案例fun noRunBlocking(args: Array) {    val job = launch(CommonPool) {        delay(1000L)    }    // 这里会报Suspend function 'join' should be called only from a coroutine or another suspend function    job.join()}

2. 在Coroutine中异步执行suspend方法

我们可以通过async在不同的Dispather提供的线程中运行以后，带回返回值，如下:

fun main(args: Array) = runBlocking {    // 计算总共需要执行多久，measureTimeMillis是kotlin标准库中所提供的方法    val time = measureTimeMillis {        val one = async(CommonPool) { doOne() } // 这里将doOne抛到CommonPool中的线程执行，并在结束时将结果带回来。        val two = async(CommonPool) { doTwo() } // 这里将doTwo抛到CommonPool中的线程执行，并在结束时将结果带回来。        println("The answer is ${one.await() + two.await()}") // 这里会输出6    }    println("${time}ms") // 由于doOne与doTwo在异步执行，因此这里输出大概是700ms}suspend fun doOne() : Int {    delay(500L)    return 1}suspend fun doTwo() : Int {    delay(700L)    return 5}

如果你希望在有使用到async结果返回值的时候再执行里面的内容（有点类似lazy)，只需要在构建async的时候传入CoroutineStart.LAZY作为start就可以了，比如:

12val one = async(CommonPool, CoroutineStart.LAZY) { doOne() } // 这里将doOne将不会立马执行println("${one.await()"} // 此时将会挂起当前上下文等待doOne执行完成，然后输出返回值

可以使用fun asyncXXX() = async(CommonPool) { ... } 申明一个异步的suspending方法，与launch(CommonPool)相同可以在非coroutine的区域调用。

fun asyncDoOne() = async(CommonPool) { // 创建在CommonPool这个线程池中的coroutine，并且会带回doOne的结果。    doOne()}fun main(args: Array) { // 普通方法    val one = asyncDoOne()    println("${one.await()}") // 输出doOne结果}

3. 为Coroutine指定不同的线程(Dispaters)

在协程中包含了很多CoroutineDispatcher，这些Dispaters决定了Coroutine运行所在线程。比如:

[if !supportLists]o [endif]Unconfined: 执行coroutine是在调用者的线程，但是当在coroutine中第一个挂起之后，后面所在的线程将完全取决于调用挂起方法的线程(如delay一般是由kotlinx.coroutines.DefaultExecutor中的线程调用)

[if !supportLists]o [endif]CoroutineScope#coroutineContext(旧版本这个变量名为context): 执行coroutine始终都是在coroutineContext所在线程(coroutineContext就是CoroutineScope的成员变量，因此就是CoroutineScope实例所在coroutine的线程)，

[if !supportLists]o [endif]CommonPool: 执行coroutine始终都是在CommonPool(ForkJoinPool)线程池提供的线程中；使用CommonPool这个context可以有效使用CPU多核,CommonPool中的线程个数与CPU核数一样。

[if !supportLists]o [endif]newSingleThreadContext: 执行coroutine始终都是在创建的单线程中

[if !supportLists]o [endif]newFixedThreadPoolContext: 执行的coroutine始终都是在创建的fixed线程池中

如以下案例:

// 我们在主线程调用了main方法fun main(args: Array) = runBlocking {    val jobs = arrayListOf()    jobs += launch(Unconfined) {        println("      'Unconfined': I'm working in thread ${Thread.currentThread().name}") // 这里将在主线程访问        delay(500)        println("      'Unconfined': After delay in thread ${Thread.currentThread().name}") // 这里将在DefaultExecutor中被访问    }    jobs += launch(coroutineContext) { // 父coroutine的coroutineContext, runBlocking的coroutine，因此始终在主线程        println("'coroutineContext': I'm working in thread ${Thread.currentThread().name}")        delay(1000)        println("'coroutineContext': After delay in thread ${Thread.currentThread().name}")    }    jobs.forEach { it.join() }}

输出(我们可以很清晰的看到，使用coroutineContext的始终运行在主线程，而Unconfined的在挂起后在delay的调用线程DefaultExecutor执行):

      'Unconfined': I'm working in thread main'coroutineContext': I'm working in thread main      'Unconfined': After delay in thread kotlinx.coroutines.DefaultExecutor'coroutineContext': After delay in thread main

在不同线程间跳跃

// 创建一个方法在输出前输出当前线程名fun log(msg: String) = println("[${Thread.currentThread().name}] $msg")val ctx1 = newSingleThreadContext("Ctx1")val ctx2 = newSingleThreadContext("Ctx2")runBlocking(ctx1) {    log("Started in ctx1")    delay(1000L)    run(ctx2) {        log("Working in ctx2")        delay(1000L)    }    log("Back to ctx1")}

输出:

[Ctx1] Started in ctx1[Ctx2] Working in ctx2[Ctx1] Back to ctx1

run方法使得运行在父coroutine，但是是在Ctx2线程中执行区块，以此实现线程跳跃。

4. 对于Job的取消操作

我们知道launch返回回来的是一个Job用于控制其coroutine，并且我们也可以通过coroutineContext[Job]在在CoroutineScope中获取当前Job对象。

而对于Job的取消操作可以理解为类似线程中的Thread.interrupt()，我们可以通过Job#cancel对job进行取消。

需要特别注意的是默认的delay等都可以被取消的(delay对CancellationException默认的处理方式就是直接中断所有操作达到被取消的目的)，但是如果我们自己做一些逻辑操作，或者是select等没有做取消检查，取消是无效的，最简单的方法是检查CoroutineScope#isActive，在coroutine中都可以对其进行访问。 如:

fun main(args: Array) = runBlocking {    val job = launch(CommonPool) {        ...        while (isActive) { // 检查是否需要结束当前自旋            ...        }    }    ...    job.cancel() // 暂停该job    ...}

对父coroutine进行取消，除了取消了coroutine本身，还会影响使用其CoroutineScope#context的子job，但是不会影响使用其他CoroutineContext的job，如:

// 创建一个运行在CommonPool线程池中的Coroutineval request = launch(CommonPool) {        // 创建一个运行在CommonPool线程池中的coroutine        val job1 = launch(CommonPool) {            println("job1: I have my own context and execute independently!")            delay(1000)            println("job1: I am not affected by cancellation of the request")        }        // 创建一个运行在父CoroutineContext上的coroutine        val job2 = launch(coroutineContext) {            println("job2: I am a child of the request coroutine")            delay(1000)            println("job2: I will not execute this line if my parent request is cancelled")        }        // 让当前coroutine只有在job1与job2完成之前都挂起        job1.join()        job2.join()    }delay(500)request.cancel() // 取消delay(1000) // delay a second to see what happensprintln("main: Who has survived request cancellation?")

输出(其中没有使用父coroutineContext的job1不受父coroutine取消的影响):

job1: I have my own context and execute independently!job2: I am a child of the request coroutinejob1: I am not affected by cancellation of the requestmain: Who has survived request cancellation?

4.1 对于Job取消以后的处理

比如对delay之类的suspending期间，被取消了，我们应该如何捕捉到进行相关处理呢，这块可以直接使用try{ ... } finally { ... }进行捕捉处理。

但是需要注意的是，一般来说对于已经取消的Job是无法进行suspending操作的，换句话说，你在上面提到的finnaly { ... }再做suspending相关操作会收到CancellationException的异常。

不过如果非常特殊的情景，需要在已经取消的Job中进行suspending操作，也是有办法的，那就是放到run(NonCancellable) { ... }中执行，如:

fun main(args: Array) = runBlocking {    val job = launch(CommonPool) {        try {            repeat(1000) { i ->                ...            }        } finally {            run(NonCancellable) {                ...// 在已经取消的Job中                delay(1000L) // 由于是在 run(NonCancellable) { ... }因此依然可以做suspending操作            }        }    }    ...    job.cancel() // 取消当前job    ...}

5. 多个CoroutineContext进行+操作

这块具体可以参看CoroutineContext#plus操作实现。

coroutine中支持多个CoroutineContext进行+操作，使得一个coroutine拥有多个CoroutineContext的特性。

5.1 CoroutineContext + CoroutineDispatcher

如果使用+将CoroutineContext与CoroutineDispatcher相加，那么当前Coroutine将运行在CoroutineDispatcher分配的线程中，但是生命周期受CoroutineContext影响，如:

val request = launch(ctx1) {    val job = launch(coroutineCotext + CommonPool) {        // 当前Coroutine运行在CommonPool线程池中，但是如果ctx1被cancel了，当前Coroutine也会被cancel.        delay(1000L)    }}request.cancel() // job也会被cancel了。

5.2 CoroutineDispatcher + CoroutineName

当然也可以使用+将CoroutineDispatcher与CoroutineName相加，那么便可以给当前Coroutine命名。

5.3 CoroutineContext + Job

我们可以使用+将CoroutineContext与Job对象相加，使得Job对象可以直接管理其coroutine，如:

val job = Job() // 创建一个Job对象val coroutines = List(10) {    launch(coroutineContext + job) { // 将运行的CoroutineContext与job相加，使得job对象可以直接控制创建的coroutine        ...    }}job.cancel() // 会cancel所有与其相加的coroutine

一个比较常见的常见，我们可以为Activity创建一个job，所有需要绑定Activity生命周期的coroutine都加上这个job，在Activity销毁的时候，直接使用这个job.cancel将所有coroutine取消。

6. 对Coroutine进行超时设计

可以在协程方法内，通过withTimeout或者withTimeoutOrNull创建一个一段时间还没有完成便会自动被取消的Coroutine。

其中withTimeout在超时的时候，会抛出继承自CancellationException的TimeoutException，如果超时是被允许的，你可以通过实现try { ... } catch ( e: CancellationException ) { ... }在其中做超时之后的操作（比如释放之类的)，或者是直接使用withTimeoutOrNull。

7. 线程安全

通常我们在多个线程同时共享同一个数据的时候，是存在线程安全问题的，如:

// counter 的初始值var counter = 0fun main(args: Array) = runBlocking {    // 在CommonPool线程池中执行coutner自增    massiveRun(CommonPool) {        // 每次我们都自增一次coutiner        counter++    }    println("Counter = $counter")}suspend fun massiveRun(context: CoroutineContext, action: suspend () -> Unit) {    val n = 1000 // launch的个数    val k = 1000 // 每个coroutine中执行action的次数    val time = measureTimeMillis {        val jobs = List(n) {            launch(context) {                repeat(k) { action() }            }        }        jobs.forEach { it.join() }    }    println("Completed ${n * k} actions in $time ms")}

上面的案例我们在CommonPool线程池中对counter并行执行了100万次的自增，理论上coutiner最终值应该是1000000，但是由于多线程同时访问，使得该最终值不符合预期:

completed 1000000 actions in 1308 msCounter = 680574

7.1 加上volatile

假如我们给coutiner加上volatile呢?

@Volatilevar counter = 0

我们会发现依然无法保证 这里的线程安全问题，由于volatile变量只能保证对该变量线性的一个读写操作(这块的具体原理可以参考Java Synchronized机制这篇文章)进行保证，这里的案例大量的原子操作是volatile无法保证的:

completed 1000000 actions in 1440 msCounter = 676243

7.2 使用同步

private val lock = Any()fun main(args: Array) = runBlocking {    massiveRun(CommonPool) {        synchronized(lock) {            counter++        }    }    ...}

使用synchronized或是ReentrantLock显然是可以的，虽然操作很小，但是由于高并发的一个线程加锁，使得运行效率极低，全程消耗了11.687s:

completed 1000000 actions in 11687 msCounter = 1000000

7.3 使用Mutex进行挂起

val mutex = Mutex()var counter = 0fun main(args: Array) = runBlocking {    massiveRun(CommonPool) {        mutex.lock()        try { counter++ }        finally { mutex.unlock() }    }    ...}

类似于Java的ReentrantLock，Mutex不同的是不是采用阻塞，而是采用Coroutine的挂起代替阻塞，在一些场景下是非常实用的，不过在这里并没有想象中那么好，甚至比synchronized阻塞还差很多(48.894s)，由于每一个操作都是很小的颗粒度，导致挂起线程资源很难有被利用的场景:

completed 1000000 actions in 48894 msCounter = 1000000

7.4 使用线程安全数据结构

private val counter = AtomicInteger()fun main(args: Array) = runBlocking {    massiveRun(CommonPool) {        counter.incrementAndGet()    }    ...}

其实这个案例的最佳方案 便是使用支持原子操作incrementAndGet的AtomicInteger来代替线程锁达到线程安全，我们发现保证了线程安全并且只需要需要1.568s左右便完成了通过线程锁需要11.687s的工作(相差了7倍之多!):

12completed 1000000 actions in 1568 msCounter = 1000000

7.5 使用线程约束这边的并发颗粒度

// 创建一个单线程val counterContext = newSingleThreadContext("CounterContext")var counter = 0fun main(args: Array) = runBlocking {    massiveRun(CommonPool) { // 依然是在CommonPool运行每一个Action        run(counterContext) { // 但是在单线程中运行递增操作            counter++        }    }    ...}

这里我们使用一个单线程的context来约束这个自增操作，这个方案也是可以的，但是并不可取 ，原因是每一个自增都需要从CommonPool的上下文切换到单线程的上下文，这是累计起来是非常开销的操作，虽然最终的答案符合预期，但是总耗时达到了22.853s之多:

completed 1000000 actions in 22853 msCounter = 1000000

7.6 线程合并

val counterContext = newSingleThreadContext("CounterContext")var counter = 0fun main(args: Array) = runBlocking {    massiveRun(counterContext) { // 让每一个Action在单线程的Context中运行        counter++    }    ...}

这个其实是一个权衡方案，类似这个案例，本身Action中的所有操作就是存在线程安全的需求，那么考虑不要使用多线程，直接改为单线程操作，结果中规中矩:

completed 1000000 actions in 3113 msCounter = 1000000

7.7 使用Actor

sealed class CounterMsg // 这里我们刚好使用sealed class来定义，定义一个CounterMsgobject IncCounter : CounterMsg() // 定义一个用于自增的类型class GetCounter(val response: CompletableDeferred) : CounterMsg() // 定义一个用户获取结果的类型(这里我们使用CompletableDeferred用于带回结果)// 这个方法启动一个新的Counter Actorfun counterActor() = actor(CommonPool) {    var counter = 0    for (msg in channel) { // 不断接收channel中的数据，这个channel是ActorScope的变量        when (msg) {            is IncCounter -> counter++ // 如果是IncCounter类型，我们就自增            is GetCounter -> msg.response.complete(counter) // 如果是GetCounter类型，我们就带回结果        }    }}fun main(args: Array) = runBlocking {    val counter = counterActor() // 创建一个Actor    massiveRun(CommonPool) {        counter.send(IncCounter) // action发送自增类型，使得不断执行action不断的触发自增    }    // 创建一个CompletableDeferred用于带回结果    val response = CompletableDeferred()    counter.send(GetCounter(response)) // 发送GetCounter类型带回结果    println("Counter = ${response.await()}") // 输出结果    counter.close() // 关闭actor}

Actor是一个coroutine的结合，所有的参数可以定义与封装在这个coroutine中，并且通过channel与其他coroutine进行通信，由于Actor本身就是一个coroutine的结合，因此无论Actor运行在哪个CoroutineContext下面，Actor本身都是运行在自己的courtine中并且这是一个顺序执行的coroutine，因此我们可以用它来做线程安全的一些操作，因此在这个案例中这个是可行的，并且由于它始终都运行在同一个coroutine中不需要进行context切换，因此性能比前面提到的Mutex更好。

completed 1000000 actions in 14192 msCounter = 1000000

当然对于Actor的使用，这个案例中我们简单的通过编写方法来生成一个Actor，但是复杂的情况最好是封装为一个类。

8. 通信

8.1 Channels

协程中可以通过Channel进行通道模式的在不同coroutine中传递数据，可以发送、接收、关闭等操作，并且对于接收者来说Channel是公平的，也就是先receive的会优先收到send的推送，其余的挂主住等待，而Channel又分有缓冲区的与无缓冲区的。

8.1.1 公平的Channel

对于接收者来说Channel是公平的，也就是先receive的会优先收到send的推送，下面是一个很经典的打乒乓球的例子:

// 申明一个球的类data class Ball(var hits: Int)fun main(args: Array) = runBlocking {    val table = Channel() // 创建一个channel作为桌子    launch(coroutineContext) { player("ping", table) } // 选手一，先接球中    launch(coroutineContext) { player("pong", table) } // 选手二，也开始接球    table.send(Ball(0)) // 开球，发出第一个球    delay(1000) // 打一秒钟    table.receive() // 接球，终止在player中的循环发球}suspend fun player(name: String, table: Channel) {    for (ball in table) { // 不断接球        ball.hits++        println("$name $ball")        delay(300) // 等待300ms        table.send(ball) // 发球    }}

输出:

ping Ball(hits=1)pong Ball(hits=2)ping Ball(hits=3)pong Ball(hits=4)ping Ball(hits=5)

这个案例利用了公平的Channel机制:

receive队列发送触发者

选手一桌子

选手二选手一

选手一选手二

选手二选手一

……

桌子选手x

8.1.2 无缓冲区Channel

如果send先执行，会挂起直到有地方receive，如果receive先执行会先挂起直到有地方send，如:

fun main(args: Array) = runBlocking {    // 创建发送Int值的无缓存Channel。    val channel = Channel()    launch(CommonPool) {        // 通过channel发送，将会挂起直到当前值有人接收或者当前Coroutine被cancel        for (x in 1..5) channel.send(x * x)        // 不一定需要关闭，但是使用关闭可以结束当前channel        channel.close()    }    // 接收3个值    repeat(3) { println(channel.receive()) }    // 不断接收剩余的信息    for (y in channel) println(y)    println("Done!")}

8.1.3 有缓冲区Channel

如果receive先执行并且缓冲区中没有任何数据会先挂起，如果send先执行了，会一直send直到缓冲区满了才挂起（类似BlockingQueue)，如:

fun main(args: Array) = runBlocking {    // 创建缓冲区大小为4的Channel    val channel = Channel(4)    launch(coroutineContext) {        repeat(10) {            // 输出正在发送的Int            println("Sending $it")            // 将会执行send直到缓冲区满            channel.send(it)        }    }    // 这里我们不进行接收，只是等待，来验证最多可以缓冲多少个    delay(1000)}

输出(缓冲了4个，并且尝试发第5个):

Sending 0Sending 1Sending 2Sending 3Sending 4

8.2 Producer

生产消费者模式，可以创建生产者，以及进行消费调用，如:

// 创建一个生产者方法fun produceSquares() = produce(CommonPool) {    for (x in 1..5) send(x * x)}fun main(args: Array) = runBlocking {    // 得到生产者    val squares = produceSquares()    // 对生产者生产的每一个结果进行消费    squares.consumeEach { println(it) }}

8.3 Pipeline

管道模式，可以先创造一个生产者，然后对生产结果进行加工，最后对加工结果进行消费调用，如:

// 创建一个生产者，返回的是一个ProducerJobfun produceNumbers() = produce(CommonPool) {    var x = 1    while (true) send(x++) // infinite stream of integers starting from 1}// 创建一个用于加工生产者的生产者（ProducerJob是继承自ReceiveChannel)fun square(numbers: ReceiveChannel) = produce(CommonPool) {    for (x in numbers) send(x * x)}fun main(args: Array) = runBlocking {    val numbers = produceNumbers() // 生产者    val squares = square(numbers) // 加工    for (i in 1..5) println(squares.receive()) // 消费前5个结果    squares.cancel() // cancel加工的coroutine（一般来说是不用主动cancel的，因为协程就好像一个常驻线程，挂起也会被其他任务使用闲置资源，不过大型应用推荐cancel不使用的coroutine)    numbers.cancel() // cancel生产者的coroutine}

下面是利用pipeline计算前6位素数的案例:

// 创建一个生产者，这里是无限输出递增整数的生产者，并且使用外界传入的context，与初始值fun numbersFrom(context: CoroutineContext, start: Int) = produce(context) {    var x = start    while (true) send(x++)}// 创建方法对生产结果进行加工，这里是计算除数不为零，我们都知道素数是大于1的自然数中除了1和本身无法被其他自然数整除fun filter(context: CoroutineContext, numbers: ReceiveChannel, prime: Int) = produce(context) {    for (x in numbers) if(x % prime != 0) send(x * x)}fun main(args: Array) = runBlocking {    // 创建一个从2开始的自增的生产者    var cur = numbersfrom(context, 2)    for (i in 1..6) {        // 取得当前素数        val prime = cur.receive()        // 输出        println(prime)        // 添加一层过滤        cur = filter(context, cur, prime)    }}

整个计算素数的过程是一直在增加过滤器，抽象的流程如下:

// numbersFrom(2) -> filter(2)// 2                    3%2 != 0 send 3//                              -> filter(3)// 3                    4%2 == 0, 5%2 != 0; 5%3 != 0; send 5//                                          -> filter(5)// 5                    6%2 == 0, 7%2 != 0; 7%3 != 0; 7%5 != 0; send 7//                                                      -> filter(7)// 7                    8%2 == 0, 9%2 != 0; 9%3 == 0;//                      10%2 == 0, 11%2 != 0; 11%3 != 0; 11%5 != 0; 11%7 != 0; send 11//                                                                  -> filter(11)// 11                   12%2 == 0, 13%2 != 0; 13%3 != 0; 13%5 != 0; 13%7 != 0; 13%11 != 0; send 13// 13

上面都是pipeline的一些案例，实际使用过程中，我们通常会用于一些异步的事务处理等。

9. Select

Select可以从多个正在挂起的suspension方法中选择最先结束挂起的。

9.1 对channel消息的接收进行选择其一

我们可以使用select来同时接收多个channel，并且每次只选择第一个到达的channel:

// 每300ms发送一个channel1fun channel1(context: CoroutineContext) = produce(context) {    while (true) {        delay(300)        send("channel1")    }}// 每100ms发送一个channel2fun channel2(context: CoroutineContext) = produce(context) {    while (true) {        delay(100)        send("channel2")    }}// 每次选择先到达的一个suspend fun selectFirstChannel(channel1: ReceiveChannel, channel2: ReceiveChannel) {    select { // 这里的说明这个select没有产生任何返回值        channel1.onReceive { value ->            println(value)        }        channel2.onReceive { value ->            println(value)        }    }}fun main(args: Array)  = runBlocking {    val channel1 = channel1(coroutineContext)    val channel2 = channel2(coroutineContext)    repeat(5) {        selectFirstChannel(channel1, channel2)    }}

输出:

channel2channel2channel1channel2channel2

可以看到结果是符合预期的，由于receive操作本身如果没有数据到达就会挂起等待，因此通过这种方式，我们可以有效每次只选择先到达的一个，而无需每次都等待所有的channel被send。

上面的案例当channel被close的时候，select会抛异常，我们可以通过onReceiveOrNull让channel被close时，立马接收到null的值来取代抛异常:

suspend fun selectAorB(a: ReceiveChannel, b: ReceiveChannel): String =    select {        a.onReceiveOrNull { value ->            if (value == null)                "Channel 'a' is closed"            else                "a -> '$value'"        }        b.onReceiveOrNull { value ->            if (value == null)                "Channel 'b' is closed"            else                "b -> '$value'"        }    }fun main(args: Array) = runBlocking {    val a = produce(coroutineContext) {        repeat(4) { send("Hello $it") }    }    val b = produce(coroutineContext) {        repeat(4) { send("World $it") }    }    repeat(8) { // print first eight results        println(selectAorB(a, b))    }}

输出:

a -> 'Hello 0'a -> 'Hello 1'b -> 'World 0'a -> 'Hello 2'a -> 'Hello 3'b -> 'World 1'Channel 'a' is closedChannel 'a' is closed

从中可以看到两条结论:

[if !supportLists]o [endif]当同时有消息过来的时候，优先处理在select区块中上面的onReceive

[if !supportLists]o [endif]当判断到channl已经close时，会里面返回null而不会继续进行下一个onReceive处理，如案例中输出了两个Channel 'a' is closed，就是第7次与第8次循环时判读到a.onReceiveOrNull发现a已经close了，因此哪怕b还有消息可以接收也立即在a.onReceiveOrNull中立即返回了null而不继续b的接收处理

下面的案例在同一个select中通过onReceiveOrNull与在onAwait中的receiveOrNull来对async返回的Deferred进行选择:

// 创建一个选择Deferred的生产者fun switchMapDeferreds(input: ReceiveChannel>) = produce(CommonPool) {    var current = input.receive() // 从获取第一个Deferred开始    while (isActive) { // 循环直到被关闭或者被取消        val next = select?> { // 选择下一个Deferred如果已经关闭便返回null            input.onReceiveOrNull { update ->                update // 如果input中有新的Deferred(这个案例中是通过async返回的Deferred)发送过来便更新为当前的Deferred            }            // 如果在Deferred已经执行完成还没有新的Deferred过来，便会进行下面的操作            current.onAwait { value ->                send(value) // 发送这个Deferred携带的值给当前channel                input.receiveOrNull() // 等待并且从input中接收下一个Deferred，作为返回值            }        }        if (next == null) {            println("Channel was closed")            break // 结束循环        } else {            current = next        }    }}// 创建一个async的方法，其返回的是一个Deferredfun asyncString(str: String, time: Long) = async(CommonPool) {    delay(time)    str}fun main(args: Array) = runBlocking {    val chan = Channel>() // 创建一个传递Deferred的channel    launch(coroutineContext) { // 启动一个coroutine用于输出每次的选择结果        for (s in switchMapDeferreds(chan))            println(s)    }    chan.send(asyncString("BEGIN", 100))    delay(200) // 挂起200ms，让在switchMapDeferreds中有足够的时间让BEGIN这个Deferred完成挂起与异步操作    chan.send(asyncString("Slow", 500))    delay(100) // 挂起100ms，让在switchMapDeferreds中没有足够时间让Slow这个Defferred完成挂起与异步操作    chan.send(asyncString("Replace", 100)) // 在上面挂起 100ms毫秒以后，立马发送这个Replace的    delay(500) // 挂起500ms 让上面的async有足够时间    chan.send(asyncString("END", 500))    delay(1000) // 挂起500ms 让上面的async有足够时间    chan.close() // 关闭channel    delay(500) // 延缓500ms让switchMapDeferreds有足够的时间输出'Channel was closed'}

输出:

BEGINReplaceENDChannel was closed

9.2 对channel消息的发送进行选择其一

我们可以使用select来同时管理多个channel的发送，并且每次只选择第一个有人在接收的channel:

fun produceNumbers(side: SendChannel) = produce(CommonPool) {    for (num in 1..10) { // 产生从1到10 10个数字        delay(100) // 每100ms选择一个发送        select {            // 哪个channel先有人接收，哪个将会被发送出去，另一个会被丢弃            onSend(num) {} // 发送给当前channel            side.onSend(num) {} // 或者发送给side channel        }    }}fun main(args: Array) = runBlocking {    val side = Channel() // 创建一个side channel，用于发送Int数据    launch(coroutineContext) { // 创建一个快速接收side数据的消费者coroutine        side.consumeEach { println("Side channel has $it") }    }    // 主channel每250ms接收一个数据    produceNumbers(side).consumeEach {        println("Consuming $it")        delay(250)    }    println("Done consuming")}

输出:

Consuming 1Side channel has 2Side channel has 3Consuming 4Side channel has 5Side channel has 6Consuming 7Side channel has 8Side channel has 9Consuming 10Done consuming

总的来说，Kotlin的协程可以应用的场景非常的宽泛，也非常的实用，从对线程阻塞这块资源利用的出发点，衍生出各种各样的实用场景，如果能够灵活使用，将能编写出更优质，更高效的代码

你可能感兴趣的:(2020-03-19 Android Kotlin Coroutines 延时处理)

  • ArcGIS连接达梦数据库创建空间数据库 山雨同学 数据库arcgis
    1.安装64位或32位达梦数据库；2.用DM管理工具连接数据库运行一下代码，创建DMGEO系统包。SP_INIT_GEO_SYS(1);3.若在本机使用ArcGIS连接，数据库安装的是64位数据库，必须安装32位的客户端（另建文件夹），将32位客户端的bin文件夹下文件复制到ArcGIS的bin文件夹下，重复文件跳过处理。远程连接，在安装ArcGIS的电脑安装安装32位DM客户端，同样将32位客户
  • MySQL存储引擎 JustGopher MySQL数据库mysql数据库
    MySQL体系结构连接层最上层是一些客户端和连接服务，主要完成一些类似于连接处理、授权认证、及相关的安全方案。服务器也会为每个安全接入的用户端验证它所具有的操作权限。服务层第二层架构主要完成大多数的核心服务功能，如SQL接口，并完成缓存的查询，SQL的分析和优化、部分内置函数的执行。所有跨存储引擎的功能也在这一层实现，如：过程、函数等。引擎层存储引擎真正的负责了MySQL中数据的存储和提取，服务器
  • Yarn vs npm：你了解了吗 那只斑马不睡觉 npmjavascript前端
    奠定基础回到过去，一个简单的文本编辑器就足以让开发人员创建和管理他们的大部分项目。但从那时起，Web发生了翻天覆地的变化。如今，即使是一个相当简单的项目也很常见，拥有数百或数千个脚本，具有复杂的嵌套依赖项，如果没有某种自动化工具，这些脚本根本无法管理。这就是管理器发挥作用的地方。包管理器是一种以多种方式自动处理项目依赖关系的工具。例如，在包管理器的帮助下，我们可以安装、卸载、更新和升级包，配置项目
  • mysql存储函数 小冯爱编程 mysql数据库sql
    文章目录存储函数一、创建存储函数二、调用存储函数存储函数我们学过很多函数，使用这些函数可以对数据进行的各种处理操作，极大地提高用户对数据库的管理效率。MySQL支持自定义函数，定义好之后，调用方式与调用MySQL预定义的系统函数一样，比如AVG、COUNT、SUBSTR等。一、创建存储函数CREATEFUNCTION函数名(参数名参数类型,...)RETURNS返回值类型[characterist
  • 基于RandomAccessFile的文件分片多线程读取的优化与拓展应用 寒冰碧海 Java爬坑之路java
    一、引言在上一篇文章（原文章链接）中，我们深入探讨了利用多线程分片读取文件内容的精妙实现。通过精心设计的代码逻辑，从文件按指定位置、大小划分分片，再借助多线程并发读取，最终无缝合并内容。然而，“金无足赤”，该方法在处理超大规模文件时，暴露出一个严峻的问题——全量读取文件易导致内存溢出。当文件体量如巨兽般庞大，一股脑地将所有数据读入内存，就如同往一个有限容量的容器里拼命注水，内存占用必然超标，进而引
  • Java 多线程精准定位毫秒级分片读取大文件实战 寒冰碧海 Java爬坑之路java开发语言
    一、引言在处理大文件读取任务时，传统的单线程读取方式往往效率低下，无法满足性能要求。本文将深入探讨一种基于Java多线程的分片读取文件方案，并结合实际代码进行详细剖析与性能分析。二、技术背景当文件体积庞大时，一次性读取整个文件会消耗大量内存且耗时较长。采用多线程分片读取策略，能够充分利用多核处理器的优势，将文件划分为多个片段，每个线程负责读取一个片段，最后合并结果，从而显著提升读取效率。三、代码实
  • Linux 王某人996 Linux
    一、概述1.1Linux的历史操作系统，英语OperatingSystem简称为OS。说道操作系统就需要先讲一讲Unix，UNIX操作系统，是一个强大的多用户、多任务操作系统，支持多种处理器架构，按照操作系统的分类，属于分时操作系统，最早由KenThompson、DennisRitchie和DouglasMcIlroy于1969年在AT&T的贝尔实验室开发。而linux就是一款类Unix系统。通常
  • v3+ts/request封装axios 赵不困888（合作私信） java前端javascript
    1.创建一个新的axios实例2.请求拦截器，如果有token进行头部携带3.响应拦截器a.剥离无效数据b.处理token失效4.导出一个函数，调用当前的axios实例发请求，返回值promiseimportaxios,{AxiosError,typeMethod}from'axios'import{useUserStore}from'@/stores/user'//pinia存储importro
  • OpenAI的编程语言和框架，给程序员带来了帮助有哪些 API技术大佬Anzexi58 OpenAI人工智能人工智能深度学习
    OpenAI是一个人工智能开发公司，成立于2015年，总部位于美国旧金山。这家公司致力于研究和开发先进的人工智能技术，旨在将这些技术应用到解决全球一些最棘手的问题上。OpenAI以其卓越的技术和实验室出品的groundbreakingAIpapers而闻名。OpenAI的研究涉及深度学习、自然语言处理、视觉感知、强化学习等多个领域，并已在各种应用中取得了令人瞩目的成果。例如，在机器人领域，Open
  • Python之Spire.XLS进行Excel与CSV文件互转换 一晌小贪欢 Python自动化办公pythonexcelpython办公python自动化
    目录专栏导读背景安装Excel转CSV文件(推荐速度会快一点)代码CSV转Excel文件(小文件推荐)代码结尾专栏导读欢迎来到Python办公自动化专栏—Python处理办公问题，解放您的双手️‍博客主页：请点击——>一晌小贪欢的博客主页求关注该系列文章专栏：请点击——>Python办公自动化专栏求订阅文章作者技术和水平有限，如果文中出现错误，希望大家能指正❤️欢迎各位佬关注！❤️背景安装我们利用
  • 解放文档处理：Spire.Doc 去水印版本推荐 颜栩原
    解放文档处理：Spire.Doc去水印版本推荐【下载地址】Spire.Doc去水印版本下载Spire.Doc去水印版本下载项目地址:https://gitcode.com/open-source-toolkit/29fe3项目介绍在日常的开发工作中，文档处理是一个常见且重要的任务。无论是生成报告、编辑模板，还是进行格式转换，一个高效、稳定的文档处理库都是不可或缺的。Spire.Doc作为一款功能强
  • CryEngine引擎开发：网络游戏开发_CryEngine引擎概述 chenlz2007 游戏开发cryengine游戏引擎网络php服务器
    CryEngine引擎概述引擎架构CryEngine是一款高性能的游戏开发引擎，专为动作游戏类项目的开发而设计。它由多个子系统组成，每个子系统都有其独特的功能和职责。了解这些子系统的架构对于有效地使用CryEngine进行网络游戏开发至关重要。1.渲染系统CryEngine的渲染系统是其最引以为豪的子系统之一。它支持先进的图形技术，如实时全局光照、物理渲染、高动态范围（HDR）和后处理效果。这些技
  • python with的用法 weixin_33935777 python
    原文链接With语句是什么?有一些任务，可能事先需要设置，事后做清理工作。对于这种场景，Python的with语句提供了一种非常方便的处理方式。一个很好的例子是文件处理，你需要获取一个文件句柄，从文件中读取数据，然后关闭文件句柄。如果不用with语句，代码如下：file=open("/tmp/foo.txt")data=file.read()file.close()这里有两个问题:一是可能忘记关闭
  • 深入理解 Python 之 with 语句 Phoenixtree_DongZhao 随笔pythonpython
    浅谈Python的with语句深入理解Python王生辉,李骅宸发布:2011-12-02引言with语句是从Python2.5开始引入的一种与异常处理相关的功能（2.5版本中要通过fromfutureimportwith_statement导入后才可以使用），从2.6版本开始缺省可用（参考What’snewinPython2.6?中with语句相关部分介绍）。with语句适用于对资源进行访问的场
  • Python中的 with语句 奶糖芯 pythonpython开发语言后端
    Python中的with语句在开发中有一些任务，有可能是需要事情进行设置，然后在事后又需要进行清理工作；对于这种场景，with语句就提供了很方便的处理方式；最常见就是对于文件的操作；不使用with语句这样写①有可能忘记关闭文件句柄，②读取文件出现异常处理也没有进行任何的处理；file=open("a.txt")data=file.read()file.close()改为有处理版本（这样代码看起来有
  • Python框架区别是什么？比较常用的框架有哪些？ 其实还好啦 python编程语言
    前言本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理。众所周知，Python开发框架大大减少了开发者不必要的重复劳动，提高了项目开发效率的同时，还使得创建的程序更加稳定。目前比较主流的Python框架都有哪些呢？一般大家用的比较多的是Django、Flask、Scrapy、Diesel、Cubes、Pulsar和Tornado。那
  • 第三章：实时流数据处理与分析 深度学习客 大数据技术进阶linqc#数据分析
    目录3.1流处理框架深入解析与实战Flink与KafkaStreams的性能对比：事件驱动架构的代码实现1.ApacheFlink：流处理的“性能怪兽”2.KafkaStreams：轻量级、低延迟的流式处理框架实时异常检测与报警系统：结合FlinkCEP（ComplexEventProcessing）进行实现3.2低延迟流处理优化数据流式计算中的状态管理与容错机制：FlinkCheckpointi
  • Go-并行编程新手指南 jimiStephen golang开发语言后端
    Go并行编程新手指南在Go语言中，并行编程是充分利用多核CPU资源、提升程序性能的重要手段。它的核心概念包括goroutine和channel，这些特性使得Go在处理并发任务时表现出色。goroutine：轻量级的并发执行单元goroutine是Go并行编程的基础。它类似于线程，但更为轻量级。与传统线程相比，创建和销毁goroutine的开销极小，且栈空间可按需动态增长。在Go语言中，只需在函数调
  • 探索OpenAI Python SDK: 智能编程新里程 周澄诗Flourishing
    探索OpenAIPythonSDK:智能编程新里程openai-pythonTheofficialPythonlibraryfortheOpenAIAPI项目地址:https://gitcode.com/gh_mirrors/op/openai-python如果你对人工智能和自然语言处理有浓厚的兴趣，那么这个项目将为你开启新的探索之门——。这是一个由OpenAI开发的Python库，用于与他们的A
  • Upgini: 智能数据搜索与丰富化引擎 - 提升机器学习和人工智能模型准确性的利器 2401_87189860 人工智能机器学习
    Upgini:智能数据搜索与丰富化引擎在当今数据驱动的世界中,机器学习和人工智能模型的准确性至关重要。然而,提高模型准确性往往是一项艰巨的任务,需要大量的特征工程和数据处理工作。幸运的是,Upgini这一创新的Python库为数据科学家和机器学习工程师提供了一个强大的解决方案。Upgini的核心功能Upgini是一个智能数据搜索和丰富化引擎,专为机器学习和AI设计。它的主要功能包括:自动特征发现与
  • FragPipe: 一个强大的蛋白质组学数据分析平台 2401_87189860 数据分析数据挖掘
    FragPipe简介FragPipe是一个由Nesvizhskii实验室开发的综合性蛋白质组学数据分析平台。它以MSFragger搜索引擎为核心,集成了多种功能强大的分析工具,为研究人员提供了从原始数据处理到生物学解释的一站式解决方案。FragPipe具有用户友好的Java图形用户界面(GUI),同时也支持命令行模式,可以在Windows、Linux或云环境中运行。FragPipe的主要特点快速高
  • STM32 按键密码系统的实现 2401- stm32嵌入式硬件单片机
    本次基于STM32F407开发板，来实现密码系统，输入四位密码，密码正确时LED1亮，密码错误时四个LED灯双闪。LED双闪代码简单的逻辑，让四个LED灯先亮然后再延时一会LED灯灭，循环4此实现双闪的效果。按键密码的实现前面我们写了一个按键按下返回1否则返回0的函数（在按键配置的那一章），根据这个函数来进行按键密码的实现，定义一个数组，使其按键一按下为密码一，按键二按下为密码二，按键三为密码三，
  • Lucene常用的字段类型&lucene检索打分原理 学会了没 全文检索lucene打分字段
    在ApacheLucene中，Field类是文档中存储数据的基础。不同类型的Field用于存储不同类型的数据（如文本、数字、二进制数据等）。以下是一些常用的Field类型及其底层存储结构：TextField：用途：用于存储文本数据，并对其进行分词和索引。底层存储结构：文本数据会被分词器（Analyzer）处理，将文本分割成词项（terms）。每个词项会被存储在倒排索引（invertedindex）
  • java爬虫工具Jsoup学习 Future_yzx java爬虫学习
    目录前言一、基本使用二、爬取豆瓣电影的案例三、Jsoup能做什么？四、Jsoup相关概念五、Jsoup获取文档六、定位选择元素七、获取数据八、具体案例前言JSoup是一个用于处理HTML的Java库，它提供了一个非常方便类似于使用DOM，CSS和jquery的方法的API来提取和操作数据。一、基本使用org.jsoupjsoup1.13.1二、爬取豆瓣电影的案例publicclassDouBan{
  • Netty和Websocket的区别 moton2017 websocket网络协议网络
    Netty和WebSocket没有直接可比性，因为它们在网络编程环境中具有不同的用途。Netty：Netty是一个高性能、事件驱动的网络框架，用于用Java构建网络应用程序。它提供了一组用于处理各种网络协议（例如TCP和UDP）的工具和抽象。Netty通常用于构建需要低延迟、高吞吐量通信的服务器和客户端。Websocket：WebSocket是一种通信协议，可通过单个长期连接提供全双工通信通道。它
  • linux-LAMP搭建 Theshaye linux系统服务器linuxapache
    LAMP1.架构描述LAMP是一个C/S架构的平台：web客户端基于tcp/ip协议，发出http请求，服务端进行回应，用户的请求可能是动态的也可能是静态的。web服务器通过用户发送的url后缀判断动静态请求：静态请求web服务器直接处理静态请求web服务器转发给后台应用服务器去处理：(CGI)php运行的后台程序apache与php所处环境不同决定其通讯方式不同：安装在同一台服务器，就默认使用系
  • i7 12800hx和i9 11980hk差距 m0_52331396 cpucpu
    酷睿i9-11980HK采用了8核16线程设计，其基准频率为2.6GHz，最大频率为5.0GHz，并拥有24MB的三级缓存，同时集成锐炬IrisXeUHD核显并支持处理器超频，在连接性方面，i9-11980HK支持PCIe4.0、Thunderbolt4、Wi-Fi6/6E技术。其TDP范围在45-65W之间。笔记本cpu选i911980hk还是i712800hx这些点很重要http://www.
  • Python 实现车牌识别 菜狗小测试 Python技术专栏python计算机视觉opencv
    一、车牌识别的基本原理车牌识别主要包括以下几个步骤：图像采集：通过摄像头或其他图像采集设备获取包含车牌的图像。图像预处理：对采集到的图像进行灰度化、滤波、增强等操作，以提高图像的质量和清晰度，便于后续的处理。车牌定位：从预处理后的图像中找出车牌的位置。这可以通过一些特征提取和机器学习算法来实现，例如基于颜色特征、边缘特征等方法来定位车牌区域。字符分割：将定位到的车牌区域中的字符分割开，以便对每个字
  • 色度采样（4:4:4、4:2:2、4:2:0、4:1:1）详解 又吹风_Bassy 视频压缩技术图像处理色度采样YUV颜色空间视频编码标准
    色度采样（4:4:4、4:2:2、4:2:0、4:1:1）详解色度采样概述色度采样（ChromaSubsampling）是一种在图像和视频处理中，通过减少色度分量（U、V）的采样量来压缩数据的技术。它利用了人眼对亮度（Luma，Y）比色度（Chroma，U/V）更加敏感的特性，从而在不明显影响视觉效果的前提下，显著降低数据量。在YUV颜色空间中，Y表示亮度，U和V表示色度分量。通过减少U和V的采样
  • Solon2 接口开发: 熟悉 Gateway 组合缺一 SolonJavaFrameworkgatewayjavasolon
    Gateway是Solon框架的特殊控制器（也是Handler的一个实现类）。它通过注册收集之后，在局部范围内提供：二级路由、拦截、过滤、融断、异常处理等功能，并统一到网关处理。另一个作用：可以为同一批接口安排多个网关，进而定制不同的协议效果。1、定义2个组件API_0@Component(tag="api")publicclassAPI_0{@MappingpublicResultexec(){
  • 多线程编程之存钱与取钱 周凡杨 javathread多线程存钱取钱
      生活费问题是这样的：学生每月都需要生活费，家长一次预存一段时间的生活费，家长和学生使用统一的一个帐号，在学生每次取帐号中一部分钱，直到帐号中没钱时 通知家长存钱，而家长看到帐户还有钱则不存钱，直到帐户没钱时才存钱。   问题分析：首先问题中有三个实体，学生、家长、银行账户，所以设计程序时就要设计三个类。其中银行账户只有一个，学生和家长操作的是同一个银行账户，学生的行为是
  • java中数组与List相互转换的方法 征客丶 JavaScriptjavajsonp
    1.List转换成为数组。（这里的List是实体是ArrayList) 　　调用ArrayList的toArray方法。 　　toArray 　　public T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组；返回数组的运行时类型就是指定数组的运行时类型。如果列表能放入指定的数组，则返回放入此列表元素的数组。否则，将根据指定数组的运行时类型和此列表的大小分
  • Shell 流程控制 daizj 流程控制if elsewhilecaseshell
    Shell 流程控制 和Java、PHP等语言不一样，sh的流程控制不可为空，如(以下为PHP流程控制写法)： <?php if(isset($_GET["q"])){ search(q);}else{// 不做任何事情} 在sh/bash里可不能这么写，如果else分支没有语句执行，就不要写这个else，就像这样 if else if if 语句语
  • Linux服务器新手操作之二 周凡杨 Linux 简单 操作
    1.利用关键字搜寻Man Pages    man -k keyword  其中-k 是选项，keyword是要搜寻的关键字 如果现在想使用whoami命令，但是只记住了前3个字符who，就可以使用 man -k who来搜寻关键字who的man命令       [haself@HA5-DZ26 ~]$ man -k
  • socket聊天室之服务器搭建 朱辉辉33 socket
    因为我们做的是聊天室，所以会有多个客户端，每个客户端我们用一个线程去实现，通过搭建一个服务器来实现从每个客户端来读取信息和发送信息。    我们先写客户端的线程。 public class ChatSocket extends Thread{ Socket socket; public ChatSocket(Socket socket){ this.sock
  • 利用finereport建设保险公司决策分析系统的思路和方法 老A不折腾 finereport金融保险分析系统报表系统项目开发
    决策分析系统呈现的是数据页面，也就是俗称的报表，报表与报表间、数据与数据间都按照一定的逻辑设定，是业务人员查看、分析数据的平台，更是辅助领导们运营决策的平台。底层数据决定上层分析，所以建设决策分析系统一般包括数据层处理（数据仓库建设）。   项目背景介绍 通常，保险公司信息化程度很高，基本上都有业务处理系统（像集团业务处理系统、老业务处理系统、个人代理人系统等）、数据服务系统（通过
  • 始终要页面在ifream的最顶层 林鹤霄
    index.jsp中有ifream，但是session消失后要让login.jsp始终显示到ifream的最顶层。。。始终没搞定，后来反复琢磨之后，得到了解决办法，在这儿给大家分享下。。 index.jsp--->主要是加了颜色的那一句 <html> <iframe name="top" ></iframe> <ifram
  • MySQL binlog恢复数据 aigo mysql
    1，先确保my.ini已经配置了binlog：   # binlog log_bin = D:/mysql-5.6.21-winx64/log/binlog/mysql-bin.log log_bin_index = D:/mysql-5.6.21-winx64/log/binlog/mysql-bin.index log_error = D:/mysql-5.6.21-win
  • OCX打成CBA包并实现自动安装与自动升级 alxw4616 ocxcab
    近来手上有个项目,需要使用ocx控件 (ocx是什么? http://baike.baidu.com/view/393671.htm) 在生产过程中我遇到了如下问题. 1. 如何让 ocx 自动安装?     a) 如何签名?     b) 如何打包?     c) 如何安装到指定目录? 2.
  • Hashmap队列和PriorityQueue队列的应用 百合不是茶 Hashmap队列PriorityQueue队列
      HashMap队列已经是学过了的,但是最近在用的时候不是很熟悉,刚刚重新看以一次,   HashMap是K,v键 ,值     put()添加元素      //下面试HashMap去掉重复的 package com.hashMapandPriorityQueue; import java.util.H
  • JDK1.5 returnvalue实例 bijian1013 javathreadjava多线程returnvalue
    Callable接口： 返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。 Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。        ExecutorService接口方
  • angularjs指令中动态编译的方法(适用于有异步请求的情况) 内嵌指令无效 bijian1013 JavaScriptAngularJS
            在directive的link中有一个$http请求，当请求完成后根据返回的值动态做element.append('......');这个操作，能显示没问题，可问题是我动态组的HTML里面有ng-click，发现显示出来的内容根本不执行ng-click绑定的方法！     
  • 【Java范型二】Java范型详解之extend限定范型参数的类型 bit1129 extend
    在第一篇中，定义范型类时，使用如下的方式：   public class Generics<M, S, N> { //M,S,N是范型参数 }  这种方式定义的范型类有两个基本的问题：   1. 范型参数定义的实例字段，如private M m = null;由于M的类型在运行时才能确定，那么我们在类的方法中，无法使用m，这跟定义pri
  • 【HBase十三】HBase知识点总结 bit1129 hbase
    1. 数据从MemStore flush到磁盘的触发条件有哪些？    a.显式调用flush，比如flush 'mytable'    b.MemStore中的数据容量超过flush的指定容量，hbase.hregion.memstore.flush.size,默认值是64M 2. Region的构成是怎么样？ 1个Region由若干个Store组成
  • 服务器被DDOS攻击防御的SHELL脚本 ronin47
    mkdir /root/bin vi /root/bin/dropip.sh #!/bin/bash/bin/netstat -na|grep ESTABLISHED|awk ‘{print $5}’|awk -F:‘{print $1}’|sort|uniq -c|sort -rn|head -10|grep -v -E ’192.168|127.0′|awk ‘{if($2!=null&a
  • java程序员生存手册-craps 游戏-一个简单的游戏 bylijinnan java
    import java.util.Random; public class CrapsGame { /** * *一个简单的赌*博游戏，游戏规则如下： *玩家掷两个骰子，点数为1到6，如果第一次点数和为7或11，则玩家胜， *如果点数和为2、3或12，则玩家输， *如果和为其它点数，则记录第一次的点数和，然后继续掷骰，直至点数和等于第一次掷出的点
  • TOMCAT启动提示NB: JAVA_HOME should point to a JDK not a JRE解决 开窍的石头 JAVA_HOME
    当tomcat是解压的时候，用eclipse启动正常，点击startup.bat的时候启动报错; 报错如下：   The JAVA_HOME environment variable is not defined correctly This environment variable is needed to run this program NB: JAVA_HOME shou
  • [操作系统内核]操作系统与互联网 comsci 操作系统
         我首先申明：我这里所说的问题并不是针对哪个厂商的，仅仅是描述我对操作系统技术的一些看法       操作系统是一种与硬件层关系非常密切的系统软件，按理说，这种系统软件应该是由设计CPU和硬件板卡的厂商开发的，和软件公司没有直接的关系，也就是说，操作系统应该由做硬件的厂商来设计和开发
  • 富文本框ckeditor_4.4.7 文本框的简单使用 支持IE11 cuityang 富文本框
    <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <title>知识库内容编辑</tit
  • Property null not found darrenzhu datagridFlexAdvancedpropery null
    When you got error message like "Property null not found ***", try to fix it by the following way: 1)if you are using AdvancedDatagrid, make sure you only update the data in the data prov
  • MySQl数据库字符串替换函数使用 dcj3sjt126com mysql函数替换
    需求：需要将数据表中一个字段的值里面的所有的  .   替换成  _   原来的数据是  site.title  site.keywords  .... 替换后要为     site_title  site_keywords   使用的SQL语句如下：   updat
  • mac上终端起动MySQL的方法 dcj3sjt126com mysqlmac
    首先去官网下载: http://www.mysql.com/downloads/ 我下载了5.6.11的dmg然后安装,安装完成之后..如果要用终端去玩SQL.那么一开始要输入很长的:/usr/local/mysql/bin/mysql 这不方便啊,好想像windows下的cmd里面一样输入mysql -uroot -p1这样...上网查了下..可以实现滴. 打开终端,输入: 1
  • Gson使用一（Gson） eksliang jsongson
    转载请出自出处：http://eksliang.iteye.com/blog/2175401 一.概述 从结构上看Json，所有的数据（data）最终都可以分解成三种类型： 第一种类型是标量（scalar），也就是一个单独的字符串（string）或数字（numbers），比如"ickes"这个字符串。 第二种类型是序列（sequence），又叫做数组（array）
  • android点滴4 gundumw100 android
    Android 47个小知识 http://www.open-open.com/lib/view/open1422676091314.html Android实用代码七段（一） http://www.cnblogs.com/over140/archive/2012/09/26/2611999.html http://www.cnblogs.com/over140/arch
  • JavaWeb之JSP基本语法 ihuning javaweb
      目录   JSP模版元素  JSP表达式  JSP脚本片断  EL表达式  JSP注释  特殊字符序列的转义处理  如何查找JSP页面中的错误   JSP模版元素    JSP页面中的静态HTML内容称之为JSP模版元素，在静态的HTML内容之中可以嵌套JSP
  • App Extension编程指南（iOS8/OS X v10.10）中文版 啸笑天 ext
             当iOS 8.0和OS X v10.10发布后，一个全新的概念出现在我们眼前，那就是应用扩展。顾名思义，应用扩展允许开发者扩展应用的自定义功能和内容，能够让用户在使用其他app时使用该项功能。你可以开发一个应用扩展来执行某些特定的任务，用户使用该扩展后就可以在多个上下文环境中执行该任务。比如说，你提供了一个能让用户把内容分
  • SQLServer实现无限级树结构 macroli oraclesqlSQL Server
    表结构如下： 数据库id path titlesort 排序 1 0 首页 0 2 0,1 新闻 1 3 0,2 JAVA 2 4 0,3 JSP 3 5 0,2,3 业界动态 2 6 0,2,3 国内新闻 1 创建一个存储过程来实现，如果要在页面上使用可以设置一个返回变量将至传过去   create procedure test as begin decla
  • Css居中div，Css居中img，Css居中文本，Css垂直居中div qiaolevip 众观千象学习永无止境每天进步一点点css
    /**********Css居中Div**********/ div.center { width: 100px; margin: 0 auto; } /**********Css居中img**********/ img.center { display: block; margin-left: auto; margin-right: auto; }
  • Oracle 常用操作(实用) 吃猫的鱼 oracle
    SQL>select text from all_source where owner=user and name=upper('&plsql_name');  SQL>select * from user_ind_columns where index_name=upper('&index_name');  将表记录恢复到指定时间段以前
  • iOS中使用RSA对数据进行加密解密 witcheryne iosrsaiPhoneobjective c
      RSA算法是一种非对称加密算法,常被用于加密数据传输.如果配合上数字摘要算法, 也可以用于文件签名. 本文将讨论如何在iOS中使用RSA传输加密数据. 本文环境 mac os  openssl-1.0.1j, openssl需要使用1.x版本, 推荐使用[homebrew](http://brew.sh/)安装. Java 8 RSA基本原理 RS
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他