Android 多个后台任务和 UI 任务串行执行的链式调用设计

作者: 雁过留声_泪落无痕 | 来源:发表于2019-09-30 15:01 被阅读0次

Android 多个后台任务和 UI 任务串行执行的链式调用设计
Android生命周期处理，多场景下的优雅实践
Android中线程形态-AsyncTask
AsyncTask中的SerialExecutor
嵌套的promise执行顺序
第1章走入并行世界（基本概念）
Python_线程详解
Android 后台任务
Android 后台任务执行
NSOperation

版本1

调用方式：

private fun testAsyncChain() {
    AsyncChain().next(AsyncChain.UI_THREAD_TYPE) {
        Toast.makeText(this@MainActivity, "begin", Toast.LENGTH_SHORT).show()
    }.next(AsyncChain.WORK_THREAD_TYPE) {
        Thread.sleep(1000L)
        1
    }.next(AsyncChain.UI_THREAD_TYPE) {
        Toast.makeText(this@MainActivity, "middle", Toast.LENGTH_SHORT).show()
        (it as Int) + 2
    }.next(AsyncChain.WORK_THREAD_TYPE) {
        Thread.sleep(3000L)
        (it as Int) + 3
    }.next(AsyncChain.UI_THREAD_TYPE) {
        Toast.makeText(this@MainActivity, "end, result: $it", Toast.LENGTH_SHORT).show()
    }.start()
}

实现代码：

package com.example.helloworld.tools

import android.os.Handler
import android.os.HandlerThread
import android.os.Looper
import java.util.*
import java.util.concurrent.atomic.AtomicBoolean
import kotlin.properties.Delegates

class AsyncChain {

    companion object {
        const val UI_THREAD_TYPE = 0
        const val WORK_THREAD_TYPE = 1
    }

    private class Task(val threadType: Int, val action: (Any?) -> Any?)

    private val lock = Object()
    private var cancelled = false
    private var lastResult: Any? = null
    private val tasks = Collections.synchronizedList(LinkedList<Task>())
    private var isExecuting: AtomicBoolean = AtomicBoolean(false)
    private val thread = HandlerThread("AsyncChain")
    private var workHandler by Delegates.notNull<Handler>()
    private val uiHandler = Handler(Looper.getMainLooper())

    fun next(threadType: Int, action: (Any?) -> Any?): AsyncChain {
        if (isExecuting.get()) {
            throw IllegalStateException("tasks are running already!")
        }

        tasks.add(Task(threadType, action))
        return this
    }

    fun start() {
        execute()
    }

    fun cancel() {
        cancelled = true
    }

    private fun execute() {
        if (isExecuting.getAndSet(true)) {
            throw IllegalStateException("tasks are running already!")
        }

        thread.start()
        workHandler = Handler(thread.looper)
        Thread() {
            try {
                for (task in tasks) {
                    if (cancelled) {
                        break
                    }

                    when {
                        task.threadType == UI_THREAD_TYPE -> uiHandler.post {
                            lastResult = task.action(lastResult)
                            synchronized(lock) {
                                lock.notify()
                            }
                        }
                        task.threadType == WORK_THREAD_TYPE -> workHandler.post {
                            lastResult = task.action(lastResult)
                            synchronized(lock) {
                                lock.notify()
                            }
                        }
                        else -> throw IllegalArgumentException("unknown thread type: ${task.threadType}")
                    }
                    synchronized(lock) {
                        lock.wait()
                    }
                }
            } finally {
                thread.quit()
            }
        }.start()
    }

}

RxJava直接就能实现（相比之下，代码会稍微多点）：

private fun testRxJava() {
    val executor = Executors.newSingleThreadExecutor()
    val scheduler = Schedulers.from(executor)
    Observable
        .create<Int> { emitter ->
            Toast.makeText(this@MainActivity, "begin", Toast.LENGTH_SHORT).show()
            emitter.onNext(0)
            emitter.onComplete()
        }
        .subscribeOn(AndroidSchedulers.mainThread())
        .observeOn(scheduler)
        .map {
            Log.v(TAG, "thread: ${Thread.currentThread().name}")
            Thread.sleep(1000L)
            1
        }
        .observeOn(AndroidSchedulers.mainThread())
        .map {
            Toast.makeText(this@MainActivity, "middle", Toast.LENGTH_SHORT).show()
            Log.v(TAG, "thread: ${Thread.currentThread().name}")
            it + 2
        }
        .observeOn(scheduler)
        .map {
            Log.v(TAG, "thread: ${Thread.currentThread().name}")
            Thread.sleep(3000L)
            it + 3
        }
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe() {
            Log.v(TAG, "thread: ${Thread.currentThread().name}")
            Toast.makeText(this@MainActivity, "end, result: $it", Toast.LENGTH_SHORT).show()
        }
}

版本2

调用方式：

private fun testAsyncChain() {
    AsyncChain().next(true, AsyncChain.UI_THREAD_TYPE) { param ->
        Toast.makeText(this@MainActivity, "begin", Toast.LENGTH_SHORT).show()
        AlertDialog
            .Builder(this)
            .setTitle("Test")
            .setMessage("waiting! confirm to run next task.")
            .setPositiveButton("confirm") { _, _ ->
                param.confirm()
            }
            .setNegativeButton("cancel") { _, _ ->
                param.cancel()
            }
            .show()
    }.next(AsyncChain.WORK_THREAD_TYPE) {
        Thread.sleep(1000L)
        1
    }.next(AsyncChain.UI_THREAD_TYPE) {
        Toast.makeText(this@MainActivity, "middle", Toast.LENGTH_SHORT).show()
        (it.lastResult as Int) + 2
    }.next(AsyncChain.WORK_THREAD_TYPE) {
        Thread.sleep(3000L)
        (it.lastResult as Int) + 3
    }.next(AsyncChain.UI_THREAD_TYPE) {
        Toast.makeText(
            this@MainActivity,
            "end, last result: ${it.lastResult}",
            Toast.LENGTH_SHORT
        ).show()
    }.start()
}

实现代码：

package com.example.helloworld.tools

import android.os.Handler
import android.os.HandlerThread
import android.os.Looper
import java.util.*
import java.util.concurrent.atomic.AtomicBoolean
import kotlin.properties.Delegates

class AsyncChain {

    companion object {
        const val UI_THREAD_TYPE = 0
        const val WORK_THREAD_TYPE = 1
    }

    private class Task(val waitToConfirm: Boolean, val threadType: Int, val action: (Param) -> Any?)

    class Param(
        var waitToConfirm: Boolean,
        var lastResult: Any?,
        private val chain: AsyncChain,
        private val lock: Object
    ) {
        fun confirm() {
            if (waitToConfirm) {
                synchronized(lock) {
                    lock.notify()
                }
            } else {
                // no need to call confirm()
            }
        }

        fun cancel() {
            chain.cancel()
            if (waitToConfirm) {
                synchronized(lock) {
                    lock.notify()
                }
            }
        }
    }

    private val lock = Object()
    private var param = Param(false, null, this, lock)
    private var cancelled = false
    private val tasks = Collections.synchronizedList(LinkedList<Task>())
    private var isExecuting: AtomicBoolean = AtomicBoolean(false)
    private val thread = HandlerThread("AsyncChain")
    private var workHandler by Delegates.notNull<Handler>()
    private val uiHandler = Handler(Looper.getMainLooper())

    fun next(threadType: Int, action: (Param) -> Any?): AsyncChain {
        return next(false, threadType, action)
    }

    fun next(waitToConfirm: Boolean, threadType: Int, action: (Param) -> Any?): AsyncChain {
        if (isExecuting.get()) {
            throw IllegalStateException("tasks are running already!")
        }

        tasks.add(Task(waitToConfirm, threadType, action))
        return this
    }

    fun start() {
        execute()
    }

    fun cancel() {
        cancelled = true
    }

    private fun doJob(task: Task) {
        param.waitToConfirm = task.waitToConfirm
        param.lastResult = task.action(param)
        if (!task.waitToConfirm) {
            synchronized(lock) {
                lock.notify()
            }
        }
    }

    private fun execute() {
        if (isExecuting.getAndSet(true)) {
            throw IllegalStateException("tasks are running already!")
        }

        thread.start()
        workHandler = Handler(thread.looper)
        Thread() {
            try {
                for (task in tasks) {
                    if (cancelled) {
                        break
                    }

                    when {
                        task.threadType == UI_THREAD_TYPE -> uiHandler.post {
                            doJob(task)
                        }
                        task.threadType == WORK_THREAD_TYPE -> workHandler.post {
                            doJob(task)
                        }
                        else -> throw IllegalArgumentException("unknown thread type: ${task.threadType}")
                    }
                    synchronized(lock) {
                        lock.wait()
                    }
                }
            } finally {
                thread.quit()
            }
        }.start()
    }

}

leehong大神在13年实现了一个版本：Android 异步链式调用设计

Android 多个后台任务和 UI 任务串行执行的链式调用设计
版本1 调用方式：实现代码： RxJava直接就能实现（相比之下，代码会稍微多点）：版本2 调用方式：实现代...
Android生命周期处理，多场景下的优雅实践
Android的Activity/Fragment都有自己的生命周期，我们调用第三方组件，UI操作，或者后台任务，...
Android中线程形态-AsyncTask
AsyncTask简介 AsyncTask可以正确、方便的使用UI线程，执行后台任务并且在UI线程中展示执行结果。...
AsyncTask中的SerialExecutor
AsyncTask是用于执行异步后台任务，并把任务执行的进度和结果传递给主线程，并在主线程中更新UI。自从Andr...
嵌套的promise执行顺序
外部promise有多个then链式调用，第一个then里面执行另一个promise，也带多个then链式调用，他...
第1章走入并行世界（基本概念）
并发和并行都可以表示两个或者多个任务一起执行，并发偏重于多个任务交替执行（多个任务间还是串行），并行是多个任务同时...
Python_线程详解
并行：任务数<=CPU数，多核CPU同时执行多个任务并发：任务书>=CPU数，单核CPU串行执行多个任务，只是切...
Android 后台任务
Android 后台任务 ServiceAndroid N（Android 7.0）和 Android O（And...
Android 后台任务执行
参考:手机休眠引发的“血案”[https://github.com/clarkehe/Android/wiki/%...
NSOperation
1.简单了解先来了解一下串行和并行串行和并行描述的是任务和任务之间的执行方式串行是任务A执行完了任务B才执行...