zcwfeng
zcwfeng

Kotlin 之 协程

Job: 控制协程的生命周期

CoroutineDispatcher: 向合适的线程分发任务；
CoroutineName: 协程的名称，调试的时候很有用；
CoroutineExceptionHandler: 处理未被捕捉的异常。

Job生命周期.png

suspend

是一个为协程的方法标记，这里是异步操作，提醒开发者

MainScope 作用域 使用例子

/MainScope/

注意防止内存泄漏需要调用cancel方法

CoroutineScope.launch() 一般用在不需要返回结果的地方，如上所示

//1. 声明
    val mScope = MainScope()
//2. delay 本身就是suspend修饰的方法
    val job1 = mScope.launch {
            delay(1000)
        }
//3. withContext 同样是suspend修饰
val job2 = mScope.launch(Dispatchers.IO) {
            withContext(Dispatchers.Main) {
                Log.e("zcwfeng","update UI")
            }
        }

mScope.launch(Dispatchers.IO) {
            val userInfo = getUserInfo()
            Log.e("zcwfeng","userInfo $userInfo")
        }

private suspend fun getUserInfo() =
        withContext(Dispatchers.IO) {
            delay(2000)
            "Kotlin"
        }

//4. 结束要调用cancel防止内存泄漏
override fun onDestroy() {
        super.onDestroy()
        mScope.cancel()
    }

源码分析：

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyStandaloneCoroutine(newContext, block) else
        StandaloneCoroutine(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}

这个是CoroutineScope 的一个扩展函数，3个参数含义：

  1. CoroutineContext 协程上下文
  2. 协程的启动模式
  3. 协程执行具体逻辑的lambda
  4. 返回一个Job

/CoroutineContext/

是一个有索引的Element集合。数据机构介于set和map中间

CoroutineContext 核心

  1. get 方法可以在数据结构Element
  2. 操作符plus 重载 （返回一个新的 context 对象，新的对象里面包含了两个里面的所有 Element，如果遇到重复的（Key 一样的），那么用+号右边的 Element 替代左边的。但是这里面注意 + 是有顺序）
  3. public operator fun plus，提供遍历当前 context 中所有 Element 的能力
  4. fun minusKey

CoroutineScope.async() 一般用于需要返回结果和并发操作

返回结果的例子

fun asyncTest(){
        mScope.launch {
            val deferred = async(Dispatchers.IO) {
                delay(2000)
                "asyncTest"
            }
            Log.e("zcwfeng",deferred.await())
        }
    }

并发例子，同时请求5个接口 并且将返回值拼接起来

等待各job执行完 将结果合并,模拟时间都是5000毫秒 所以当job1执行完时 其他job也均执行完成

 private fun asyncTest2() {
        mScope.launch {
            val job1 = async {
                // 请求1
                delay(5000)
                "1"
            }
            val job2 = async {
                // 请求2
                delay(5000)
                "2"
            }
            val job3 = async {
                // 请求3
                delay(5000)
                "3"
            }
            val job4 = async {
                // 请求4
                delay(5000)
                "4"
            }
            val job5 = async {
                // 请求5
                delay(5000)
                "5"
            }

          
            Log.e(
                "zcwfeng",
                "asyncTest2: ${job1.await()} ${job2.await()} ${job3.await()} ${job4.await()} ${job5.await()}"
            )
        }

源码解析：

public fun  CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyDeferredCoroutine(newContext, block) else
        DeferredCoroutine(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}

参数同launch，所以我们看下差异的代码 EmptyCoroutinContext

/EmptyCoroutineContext/

某些情况需要一个上下文不持有任何元素，此时就可以使用 EmptyCoroutineContext 对象。
添加这个对象到另一个上下文不会对其有任何影响。

/Job/ 控制协程的声明周期

  wait children
    +-----+ start  +--------+ complete   +-------------+  finish  +-----------+
    | New | -----> | Active | ---------> | Completing  | -------> | Completed |
    +-----+        +--------+            +-------------+          +-----------+
                     |  cancel / fail       |
                     |     +----------------+
                     |     |
                     V     V
                 +------------+                           finish  +-----------+
                 | Cancelling | --------------------------------> | Cancelled |
                 +------------+                                   +-----------+

看一个例子打印

private fun baseJobTest() {
        val coroutineContext = Job() + Dispatchers.Default + CoroutineName("myContext")
        Log.e(TAG,"$coroutineContext,${coroutineContext[CoroutineName]}")
        val newCoroutineContext = coroutineContext.minusKey(CoroutineName)
        Log.e(TAG,"$newCoroutineContext")
    }

或者直接用单元测试

@Test
    fun jobTest(){
        val coroutineContext = Job() + Dispatchers.Default + CoroutineName("myContext")
        println("$coroutineContext,${coroutineContext[CoroutineName]}")
        val newCoroutineContext = coroutineContext.minusKey(CoroutineName)
        println("$newCoroutineContext")
    }

-> 结果：
2022-03-11 11:16:08.570 29740-29761/top.zcwfeng.kotlin I/System.out:
[JobImpl{Active}@fdc8ee0, CoroutineName(myContext), Dispatchers.Default],CoroutineName(myContext)
2022-03-11 11:16:08.570 29740-29761/top.zcwfeng.kotlin I/System.out:
[JobImpl{Active}@fdc8ee0, Dispatchers.Default]

在任务层级中，每个协程都会有一个父级对象，要么是 CoroutineScope 或者另外一个 coroutine。
协程的父级 CoroutineContext 和父级协程的 CoroutineContext 是不一样的，因为有如下的公式:
【父级上下文 = 默认值 + 继承的 CoroutineContext + 参数】

Dispatchers 的种类：【Default，IO，Main，Unconfined】

  1. 一些元素包含默认值: Dispatchers.Default 是默认的 CoroutineDispatcher，以及 "coroutine" 作为默认的 CoroutineName；
  2. 继承的 CoroutineContext 是 CoroutineScope 或者其父协程的 CoroutineContext；
  3. 传入协程 builder 的参数的优先级高于继承的上下文参数，因此会覆盖对应的参数值。

看一个例子：

CoroutineContext 可以使用 " + " 运算符进行合并。由于 CoroutineContext 是由一组元素组成的，所以加号右侧的元素会覆盖加号左侧的元素，进而组成新创建的 CoroutineContext。

比如，(Dispatchers.Main, "name") + (Dispatchers.IO) = (Dispatchers.IO, "name")。

Job 用于处理协程。对于每一个所创建的协程 (通过 launch 或者 async)，它会返回一个 Job实例，该实例是协程的唯一标识，并且负责管理协程的生命周期

1. CoroutineScope.launch 函数返回的是一个 Job 对象，代表一个异步的任务。Job 具有生命周期并且可以取消。 Job 还可以有层级关系，一个Job可以包含多个子Job，当父Job被取消后，所有的子Job也会被自动取消；当子Job被取消或者出现异常后父Job也会被取消。

2. 除了通过 CoroutineScope.launch 来创建Job对象之外，还可以通过 Job() 工厂方法来创建该对象。默认情况下，子Job的失败将会导致父Job被取消，这种默认的行为可以通过 SupervisorJob 来修改。

3. 具有多个子 Job 的父Job 会等待所有子Job完成(或者取消)后，自己才会执行完成

Job状态：新创建 (New)、活跃 (Active)、完成中 (Completing)、已完成 (Completed)、取消中 (Cancelling) 和已取消 (Cancelled)。
虽然我们无法直接访问这些状态，但是我们可以访问 Job 的属性: isActive、isCancelled 和 isCompleted。

Job 的常用函数: 这些函数都是线程安全的，所以可以直接在其他 Coroutine 中调用。

  • public fun start(): Boolean
    调用该函数来启动这个 Coroutine，如果当前 Coroutine 还没有执行调用该函数返回 true，如果当前 Coroutine 已经执行或者已经执行完毕，则调用该函数返回 false
  • public fun cancel(cause: CancellationException? = null)
  • public fun invokeOnCompletion(handler: CompletionHandler): DisposableHandle

如果 Job 是正常执行完成的，则 cause 参数为 null
如果 Job 是正常取消的，则 cause 参数为 CancellationException 对象。这种情况不应该当做错误处理，这是任务正常取消的情形。所以一般不需要在错误日志中记录这种情况。
其他情况表示 Job 执行失败了。

Deferred

通过使用async创建协程可以得到一个有返回值Deferred，Deferred 接口继承自 Job 接口，额外提供了获取 Coroutine 返回结果的方法。由于 Deferred 继承自 Job 接口，所以 Job 相关的内容在 Deferred 上也是适用的。 Deferred 提供了额外三个函数来处理和Coroutine执行结果相关的操作。

源码解析：

public interface Deferred : Job {

   
    public suspend fun await(): T

    
    public val onAwait: SelectClause1

   
    @ExperimentalCoroutinesApi
    public fun getCompleted(): T

    
    @ExperimentalCoroutinesApi
    public fun getCompletionExceptionOrNull(): Throwable?
}
  • await 用来等待这个Coroutine执行完毕并返回结果。
  • getCompleted
    用来获取Coroutine执行的结果。如果Coroutine还没有执行完成则会抛出 IllegalStateException ，如果任务被取消了也会抛出对应的异常。所以在执行这个函数之前，可以通过 isCompleted 来判断一下当前任务是否执行完毕了。
  • getCompletionExceptionOrNull
    获取已完成状态的Coroutine异常信息，如果任务正常执行完成了，则不存在异常信息，返回null。如果还没有处于已完成状态，则调用该函数同样会抛出 IllegalStateException，可以通过 isCompleted 来判断一下当前任务是否执行完毕了。

SupervisorJob

Job 是有父子关系的，如果子Job 失败了父Job会自动失败，这种默认的行为可能不是我们期望的。

SupervisorJob是一个顶层函数

@Suppress("FunctionName")
public fun SupervisorJob(parent: Job? = null) : CompletableJob = SupervisorJobImpl(parent)
  • SupervisorJob 可以解决这个问题，里面的Job互不影响，子Job失败不会影响其他的Job
  • SupervisorJob(parent: Job? = null) parent参数是一个Job，如指定了参数Job，那么所有返回值都是这个Job的子Job
  • 如果传入的Parent Job取消了，那么SupervisorJob也会取消，所有Supervisor Job的子Job也会被取消

MainScope 就是 SupervisorScope 和 Main Dispatcher 实现

@Suppress("FunctionName")
public fun MainScope(): CoroutineScope = ContextScope(SupervisorJob() + Dispatchers.Main)

Retrofit 请求的一个完整的例子

data class Repo(
    val archive_url: String,
    val archived: Boolean,
    val assignees_url: String,
    val blobs_url: String,
    val branches_url: String,
    val clone_url: String,
    val collaborators_url: String,
    val comments_url: String,
    val commits_url: String,
    val compare_url: String,
    val contents_url: String,
    val contributors_url: String,
    val created_at: String,
    val default_branch: String,
    val deployments_url: String,
    val description: String,
    val disabled: Boolean,
    val downloads_url: String,
    val events_url: String,
    val fork: Boolean,
    val forks: Int,
    val forks_count: Int,
    val forks_url: String,
    val full_name: String,
    val git_commits_url: String,
    val git_refs_url: String,
    val git_tags_url: String,
    val git_url: String,
    val has_downloads: Boolean,
    val has_issues: Boolean,
    val has_pages: Boolean,
    val has_projects: Boolean,
    val has_wiki: Boolean,
    val homepage: String,
    val hooks_url: String,
    val html_url: String,
    val id: Int,
    val issue_comment_url: String,
    val issue_events_url: String,
    val issues_url: String,
    val keys_url: String,
    val labels_url: String,
    val language: String,
    val languages_url: String,
    val license: License,
    val merges_url: String,
    val milestones_url: String,
    val mirror_url: Any,
    val name: String,
    val node_id: String,
    val notifications_url: String,
    val open_issues: Int,
    val open_issues_count: Int,
    val owner: Owner,
    val `private`: Boolean,
    val pulls_url: String,
    val pushed_at: String,
    val releases_url: String,
    val size: Int,
    val ssh_url: String,
    val stargazers_count: Int,
    val stargazers_url: String,
    val statuses_url: String,
    val subscribers_url: String,
    val subscription_url: String,
    val svn_url: String,
    val tags_url: String,
    val teams_url: String,
    val trees_url: String,
    val updated_at: String,
    val url: String,
    val watchers: Int,
    val watchers_count: Int
)



interface Api {
    @GET("users/{user}/repos")
    fun listRepos(@Path("user") user: String): Call>

    @GET("users/{user}/repos")
    suspend fun listReposKt(@Path("user") user: String): List

    @GET("users/{user}/repos")
    fun listReposRx(@Path("user") user: String): Single>
}

val retrofit = Retrofit.Builder()
            .baseUrl("https://api.github.com")
            .addConverterFactory(GsonConverterFactory.create())
            .build();
 val api = retrofit.create(top.zcwfeng.kotlin.coroutine.Api::class.java)

val scopeme:CoroutineScope = MainScope()//主线程 第一种
scopeme.launch {
            val repos = async { api.listReposKt("zcwfeng") }
            val repos2 = async { api.listReposKt("google") }
            test_tv.text = "${repos.await()[0]?.name}-${repos2.await()[0]?.name}"
        }
scopeme.cancel()

/CoroutineDispatcher/ 任务调度器

  • CoroutineDispatcher 定义了 Coroutine 执行的线程。CoroutineDispatcher 可以限定 Coroutine 在某一个线程执行、也可以分配到一个线程池来执行、也可以不限制其执行的线程。

  • CoroutineDispatcher 是一个抽象类，所有 dispatcher 都应该继承这个类来实现对应的功能。

  • Dispatchers 是一个标准库中帮我们封装了切换线程的帮助类，可以简单理解为一个线程池。


    CoroutineDispatcher

  • Dispatchers.Default

Default dispatcher 使用一个共享的后台线程池来运行里面的任务。注意它和IO共享线程池，只不过限制了最大并发数不同。

  • Dispatchers.IO

是和Default共用一个共享的线程池来执行里面的任务。根据同时运行的任务数量，在需要的时候会创建额外的线程，当任务执行完毕后会释放不需要的线程。

  • Dispatchers.Unconfined
    由于Dispatchers.Unconfined未定义线程池，所以执行的时候默认在启动线程。遇到第一个挂起点，之后由调用resume的线程决定恢复协程的线程。

  • Dispatchers.Main
    指定执行的线程是主线程，在Android上就是UI线程·

CoroutineStart 协程启动模式

  • CoroutineStart.DEFAULT

协程创建后立即开始调度，在调度前如果协程被取消，其将直接进入取消响应的状态
虽然是立即调度，但也有可能在执行前被取消

  • CoroutineStart.ATOMIC

协程创建后立即开始调度，协程执行到第一个挂起点之前不响应取消
虽然是立即调度，但其将调度和执行两个步骤合二为一了，就像它的名字一样，其保证调度和执行是原子操作，因此协程也一定会执行

  • CoroutineStart.LAZY

只要协程被需要时，包括主动调用该协程的start、join或者await等函数时才会开始调度，如果调度前就被取消，协程将直接进入异常结束状态

  • CoroutineStart.UNDISPATCHED

协程创建后立即在当前函数调用栈中执行，直到遇到第一个真正挂起的点
是立即执行，因此协程一定会执行

这些启动模式的设计主要是为了应对某些特殊的场景。业务开发实践中通常使用DEFAULT和LAZY这两个启动模式就够了

CoroutineScope - 协程作用域

定义协程必须指定其 CoroutineScope 。
CoroutineScope 可以对协程进行追踪，即使协程被挂起也是如此。同调度程序 (Dispatcher) 不同，CoroutineScope 并不运行协程，它只是确保您不会失去对协程的追踪。
为了确保所有的协程都会被追踪，Kotlin 不允许在没有使用 CoroutineScope 的情况下启动新的协程。
CoroutineScope 可被看作是一个具有超能力的 ExecutorService 的轻量级版本。CoroutineScope 会跟踪所有协程，同样它还可以取消由它所启动的所有协程。
这在 Android 开发中非常有用，比如它能够在用户离开界面时停止执行协程
当异步操作比较耗时的时候，或者当异步操作出现错误的时候，需要把这个 Coroutine 取消掉来释放系统资源。
在 Android 环境中，通常每个界面（Activity、Fragment 等）启动的 Coroutine 只在该界面有意义，如果用户在等待 Coroutine 执行的时候退出了这个界面，则再继续执行这个 Coroutine 可能是没必要的。(另外 Coroutine 也需要在适当的 context 中执行，否则会出现错误,比如在非 UI 线程去访问 View)
所以 Coroutine 在设计的时候，要求在一个范围（Scope）内执行，这样当这个 Scope 取消的时候，里面所有的子 Coroutine 也自动取消。所以要使用 Coroutine 必须要先创建一个对应的 CoroutineScope。

CoroutineScope 接口

public interface CoroutineScope {
    public val coroutineContext: CoroutineContext
}
  • CoroutineScope 只是定义了一个新 Coroutine 的执行 Scope。
  • 每个 coroutine builder 都是 CoroutineScope 的扩展函数，并且自动的继承了当前 Scope 的 coroutineContextx

协程作用域 （总结）

主要用以明确写成之间的父子关系，以及对于取消或者异常处理等方面的传播行为

  • 顶级作用域 : 没有父协程的协程所在的作用域为顶级作用域。
  • 协同作用域 : 协程中启动新的协程，新协程为所在协程的子协程，这种情况下，子协程所在的作用域默认为协同作用域。

此时子协程抛出的未捕获异常，都将传递给父协程处理，父协程同时也会被取消

  • 主从作用域 : 与协同作用域在协程的父子关系上一致，区别在于，处于该作用域下的协程出现未捕获的异常时，不会将异常向上传递给父协程。

除了三种作用域中提到的行为以外，父子协程之间还存在以下规则：

  1. 父协程被取消，则所有子协程均被取消。由于协同作用域和主从作用域中都存在父子协程关系，因此此条规则都适用。
  2. 父协程需要等待子协程执行完毕之后才会最终进入完成状态，不管父协程自身的协程体是否已经执行完。
  3. 子协程会继承父协程的协程上下文中的元素，如果自身有相同key的成员，则覆盖对应的key，覆盖的效果仅限自身范围内有效。
  • 官方库给我们提供了一些作用域可以直接来使用，并且 Android 的Lifecycle Ktx库也封装了更好用的作用域
  1. GlobalScope - 不推荐使用
public object GlobalScope : CoroutineScope {
    /**
     * Returns [EmptyCoroutineContext].
     */
    override val coroutineContext: CoroutineContext
        get() = EmptyCoroutineContext
}

GlobalScope是一个单例实现，源码十分简单，上下文是EmptyCoroutineContext，是一个空的上下文，切不包含任何Job，该作用域常被拿来做示例代码，由于 GlobalScope 对象没有和应用生命周期组件相关联，需要自己管理 GlobalScope 所创建的 Coroutine，且GlobalScope的生命周期是 进程 级别的，所以一般而言我们不推荐使用 GlobalScope 来创建 Coroutine。

  1. runBlocking{} - 主要用于测试
@Throws(InterruptedException::class)
public fun  runBlocking(context: CoroutineContext = EmptyCoroutineContext, block: suspend CoroutineScope.() -> T): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    val currentThread = Thread.currentThread()
    val contextInterceptor = context[ContinuationInterceptor]
    val eventLoop: EventLoop?
    val newContext: CoroutineContext
    if (contextInterceptor == null) {
        // create or use private event loop if no dispatcher is specified
        eventLoop = ThreadLocalEventLoop.eventLoop
        newContext = GlobalScope.newCoroutineContext(context + eventLoop)
    } else {
        // See if context's interceptor is an event loop that we shall use (to support TestContext)
        // or take an existing thread-local event loop if present to avoid blocking it (but don't create one)
        eventLoop = (contextInterceptor as? EventLoop)?.takeIf { it.shouldBeProcessedFromContext() }
            ?: ThreadLocalEventLoop.currentOrNull()
        newContext = GlobalScope.newCoroutineContext(context)
    }
    val coroutine = BlockingCoroutine(newContext, currentThread, eventLoop)
    coroutine.start(CoroutineStart.DEFAULT, coroutine, block)
    return coroutine.joinBlocking()
}

运行一个新的协程并且阻塞当前可中断的线程直至协程执行完成，该函数不应从一个协程中使用，该函数被设计用于桥接普通阻塞代码到以挂起风格（suspending style）编写的库，以用于主函数与测试。该函数主要用于测试，不适用于日常开发，该协程会阻塞当前线程直到协程体执行完成。

  1. MainScope() - 可用于开发

该函数是一个顶层函数，用于返回一个上下文是SupervisorJob() + Dispatchers.Main的作用域，该作用域常被使用在Activity/Fragment，并且在界面销毁时要调用fun CoroutineScope.cancel(cause: CancellationException? = null)对协程进行取消，这是官方库中可以在开发中使用的一个用于获取作用域的顶层函数，使用示例在官方库的代码注释中已经给出，上面的源码中也有，使用起来也是十分的方便。

  1. LifecycleOwner.lifecycleScope - 推荐使用
public val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope
    get() = lifecycle.coroutineScope

/**
 * [CoroutineScope] tied to this [Lifecycle].
 *
 * This scope will be cancelled when the [Lifecycle] is destroyed.
 *
 * This scope is bound to
 * [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate]
 */
public val Lifecycle.coroutineScope: LifecycleCoroutineScope
    get() {
        while (true) {
            val existing = mInternalScopeRef.get() as LifecycleCoroutineScopeImpl?
            if (existing != null) {
                return existing
            }
            val newScope = LifecycleCoroutineScopeImpl(
                this,
                SupervisorJob() + Dispatchers.Main.immediate
            )
            if (mInternalScopeRef.compareAndSet(null, newScope)) {
                newScope.register()
                return newScope
            }
        }
    }

该扩展属性是 Android 的Lifecycle Ktx库提供的具有生命周期感知的协程作用域，它与LifecycleOwner的Lifecycle绑定，Lifecycle被销毁时，此作用域将被取消。这是在Activity/Fragment中推荐使用的作用域，因为它会与当前的UI组件绑定生命周期，界面销毁时该协程作用域将被取消，不会造成协程泄漏，相同作用的还有下文提到的ViewModel.viewModelScope。

  1. ViewModel.viewModelScope - 推荐使用
/**
 * [CoroutineScope] tied to this [ViewModel].
 * This scope will be canceled when ViewModel will be cleared, i.e [ViewModel.onCleared] is called
 *
 * This scope is bound to
 * [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate]
 */
public val ViewModel.viewModelScope: CoroutineScope
    get() {
        val scope: CoroutineScope? = this.getTag(JOB_KEY)
        if (scope != null) {
            return scope
        }
        return setTagIfAbsent(
            JOB_KEY,
            CloseableCoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
        )
    }

该扩展属性和上文中提到的LifecycleOwner.lifecycleScope基本一致，它是ViewModel的扩展属性，也是来自Android 的Lifecycle Ktx库，它能够在此ViewModel销毁时自动取消，同样不会造成协程泄漏。该扩展属性返回的作用域的上下文同样是SupervisorJob() + Dispatchers.Main.immediate

  1. coroutineScope supervisorScope

supervisorScope


public suspend fun  supervisorScope(block: suspend CoroutineScope.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return suspendCoroutineUninterceptedOrReturn { uCont ->
        val coroutine = SupervisorCoroutine(uCont.context, uCont)
        coroutine.startUndispatchedOrReturn(coroutine, block)
    }
}

coroutineScope

public suspend fun  coroutineScope(block: suspend CoroutineScope.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return suspendCoroutineUninterceptedOrReturn { uCont ->
        val coroutine = ScopeCoroutine(uCont.context, uCont)
        coroutine.startUndispatchedOrReturn(coroutine, block)
    }
}

首先这两个函数都是挂起函数，需要运行在协程内或挂起函数内。

supervisorScope属于主从作用域，会继承父协程的上下文，它的特点就是子协程的异常不会影响父协程，它的设计应用场景多用于子协程为独立对等的任务实体的时候，比如一个下载器，每一个子协程都是一个下载任务，当一个下载任务异常时，它不应该影响其他的下载任务。

coroutineScope和supervisorScope都会返回一个作用域，它俩的差别就是异常传播,coroutineScope 内部的异常会向上传播，子协程未捕获的异常会向上传递给父协程，任何一个子协程异常退出，会导致整体的退出；
supervisorScope 内部的异常不会向上传播，一个子协程异常退出，不会影响父协程和兄弟协程的运行。

协程的取消和异常

使用SupervisorJob*

    @Test
    fun cancelCourtinTest(){
        mScope.launch(Dispatchers.Default) {
            delay(500)
            Log.e(CoroutinStudyActivity.TAG, "Child 1")
        }

        mScope.launch(Dispatchers.Default) {
            delay(1000)
            Log.e(CoroutinStudyActivity.TAG, "Child 2")
            throw RuntimeException("--> RuntimeException <--")
        }

        mScope.launch(Dispatchers.Default) {
            delay(1500)
            Log.e(CoroutinStudyActivity.TAG, "Child 3")
        }
    }


--------
2022-03-13 17:03:26.671 10779-10802/? E/zcwfeng: Child 1
2022-03-13 17:03:27.169 10779-10802/? E/zcwfeng: Child 2
    
    --------- beginning of crash
2022-03-13 17:03:27.208 10779-10802/? E/AndroidRuntime: FATAL EXCEPTION: DefaultDispatcher-worker-1
    Process: top.zcwfeng.kotlin, PID: 10779
    java.lang.RuntimeException: --> RuntimeException <--
        at coroutines.Demo$cancelCourtinTest$2.invokeSuspend(KotlinCoroutines.kt:25)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:571)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:750)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:678)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:665)

MainScope()我们之前提到过了，它的实现就是用了SupervisorJob。执行结果就是Child 2抛出异常后，Child 3正常执行了，但是程序崩了，因为我们没有处理这个异常

// 在Child 2的上下文添加了异常处理
        mScope.launch(Dispatchers.Default + CoroutineExceptionHandler { coroutineContext, throwable ->
            Log.e(CoroutinStudyActivity.TAG, "CoroutineExceptionHandler: $throwable")
        }) {
            delay(1000)
            Log.e(CoroutinStudyActivity.TAG, "Child 2")
            throw RuntimeException("--> RuntimeException <--")
        }

-----------
2022-03-13 17:12:55.591 12389-12445/top.zcwfeng.kotlin E/zcwfeng: Child 1
2022-03-13 17:12:56.088 12389-12445/top.zcwfeng.kotlin E/zcwfeng: Child 2
2022-03-13 17:12:56.091 12389-12445/top.zcwfeng.kotlin E/zcwfeng: CoroutineExceptionHandler: java.lang.RuntimeException: --> RuntimeException <--
2022-03-13 17:12:56.589 12389-12445/top.zcwfeng.kotlin E/zcwfeng: Child 3

异常处理的打印也输出了，这就达到了我们想要的效果。但是要注意一个事情，这几个子协程的父级是SupervisorJob，但是他们再有子协程的话，他们的子协程的父级就不是SupervisorJob了，所以当它们产生异常时，就不是我们演示的效果了。

使用supervisorScope

@Test
    fun useSupervisorScopeTest(){
        val scope = CoroutineScope(Job() + Dispatchers.Default)
        scope.launch(CoroutineExceptionHandler { coroutineContext, throwable ->
            Log.e(
                CoroutinStudyActivity.TAG,
                "CoroutineExceptionHandler: $throwable"
            )
        }) {
            supervisorScope {
                launch {
                    delay(500)
                    Log.e(CoroutinStudyActivity.TAG, "Child 1 ")
                }
                launch {
                    delay(1000)
                    Log.e(CoroutinStudyActivity.TAG, "Child 2 ")
                    throw  RuntimeException("--> RuntimeException <--")
                }
                launch {
                    delay(1500)
                    Log.e(CoroutinStudyActivity.TAG, "Child 3 ")
                }
            }
        }
    }
-----------
2022-03-13 17:20:00.798 13771-13807/top.zcwfeng.kotlin E/zcwfeng: Child 1 
2022-03-13 17:20:01.296 13771-13807/top.zcwfeng.kotlin E/zcwfeng: Child 2 
2022-03-13 17:20:01.299 13771-13807/top.zcwfeng.kotlin E/zcwfeng: CoroutineExceptionHandler: java.lang.RuntimeException: --> RuntimeException <--
2022-03-13 17:20:01.797 13771-13807/top.zcwfeng.kotlin E/zcwfeng: Child 3

把supervisorScope 换成coroutineScope 结果就不一样了

2022-03-13 17:22:50.723 14467-14495/top.zcwfeng.kotlin E/zcwfeng: Child 1 
2022-03-13 17:22:51.220 14467-14495/top.zcwfeng.kotlin E/zcwfeng: Child 2 
2022-03-13 17:22:51.227 14467-14495/top.zcwfeng.kotlin E/zcwfeng: CoroutineExceptionHandler: java.lang.RuntimeException: --> RuntimeException <--

处理协程异常

SupervisorJob 只有作为 supervisorScope 或 CoroutineScope(SupervisorJob()) 的一部分时，才会按照上面的描述工作。

private fun baseCoroutinExecptionHandler1() {

        // Scope 控制我的应用中某一层级的协程
//        val scope = CoroutineScope(SupervisorJob())
        val scope = CoroutineScope(Job())
        scope.launch(SupervisorJob()) {
            supervisorScope {
                launch(CoroutineExceptionHandler { _, _ ->
                    Log.e(TAG, "Exception Handler supervisorScope...... Exception...")
                }) {
                    Log.e(TAG, "Exception Handler supervisorScope......child1")
                    throw RuntimeException("Test Exception")
                }

                launch {
                    Log.e(TAG, "Exception Handler supervisorScope......child2")
                }
            }
        }

不加入这个代码块supervisorScope{}和加入supervisorScope代码块是不一样的

 supervisorScope {
  ......
}

看如下代码：

给您下面一段代码，您能指出 Child 1 是用哪种 Job 作为父级的吗？
val scope = CoroutineScope(Job())
scope.launch(SupervisorJob()) {
    // new coroutine -> can suspend
   launch {
        // Child 1
    }
    launch {
        // Child 2
    }
}
job.png

Child 1 的父级 Job 就只是 Job 类型！

Async

  • 当 async 被用作根协程 (CoroutineScope 实例或 supervisorScope 的直接子协程) 时不会自动抛出异常，而是在您调用 .await() 时才会抛出异常。

  • 当 async 作为根协程时，为了捕获其中抛出的异常，您可以用 try/catch 包裹调用 .await() 的代码

private fun baseCoroutinExecptionHandler3() {
        val scope = CoroutineScope(Job())
        scope.launch {
            supervisorScope {
                val deffered = async{
                    throw RuntimeException("Test Exception")
                }
                try {
                    Log.e(TAG,"execption accor before")
                    deffered.await()// 只有await调用才会抛异常
                    Log.e(TAG,"execption accor after")
                } catch (e: Exception) {
                    Log.e(TAG,"async catch execption ${e.message}")
                }
            }
        }
    }

但是

private fun baseCoroutinExceptionHandler4() {

        val scope = CoroutineScope(Job())
        scope.launch {
            val deffered = async {
                // 如果 async 抛出异常，launch 就会立即抛出异常，而不会调用 .await()
                throw RuntimeException("Test Exception")
            }
            try {
                Log.e(TAG,"execption accor before")
                Log.e(TAG,"execption accor after")
            } catch (e: Exception) {
                Log.e(TAG,"async catch execption ${e.message}")
            }
        }
    }

由于 scope 的直接子协程是 launch，如果 async 中产生了一个异常，这个异常将就会被立即抛出。原因是 async (包含一个 Job 在它的 CoroutineContext 中) 会自动传播异常到它的父级 (launch)，这会让异常被立即抛出。
结果，打印同时，Android 程序崩溃

2022-03-14 17:43:57.890 26212-27933/top.zcwfeng.kotlin E/zcwfeng: execption accor before
2022-03-14 17:43:57.890 26212-27933/top.zcwfeng.kotlin E/zcwfeng: execption accor after
2022-03-14 17:43:57.903 26212-27933/top.zcwfeng.kotlin E/AndroidRuntime: FATAL EXCEPTION: DefaultDispatcher-worker-1
    Process: top.zcwfeng.kotlin, PID: 26212
    java.lang.RuntimeException: Test Exception
        at top.zcwfeng.CoroutinStudyActivity$baseCoroutinExceptionHandler4$1$deffered$1.invokeSuspend(CoroutinStudyActivity.kt:47)
。。。。。。

CoroutineExceptionHandler 的规则

/**
     * 以下的条件被满足时，异常就会被捕获:
     * 1. 异常是被自动抛出异常的协程所抛出的 (使用 launch，而不是 async 时)
     * 2. 在 CoroutineScope 的 CoroutineContext 中或在一个根协程
     *              (CoroutineScope 或者 supervisorScope 的直接子协程) 中
     */
    val handlerException = CoroutineExceptionHandler {
            context, exception -> println("Caught $exception")
    }

做个测试，if(boolean) 代码测试

private fun baseCoroutinExceptionHandler5() {
        val scope = CoroutineScope(Job())

        if(false) {
// <1> 在下面的代码中，异常会被 handler 捕获 
            scope.launch(handlerException) {
                launch {
                    throw Exception("Failed coroutine")
                }
            }
        } else {
// <2> 导致崩溃，异常没有捕获
            scope.launch {
                launch(handlerException) {
                    throw Exception("Failed coroutine")
                }
            }
        }

<2> 处
异常不会被捕获的原因是因为 handler 没有被安装给正确的 CoroutineContext。内部协程会在异常出现时传播异常并传递给它的父级，由于父级并不知道 handler 的存在，异常就没有被抛出

想要避免取消操作在异常发生时被传播，记得使用 SupervisorJob；反之则使用 Job。 没有被捕获的异常会被传播，捕获它们以保证良好的用户体验！
查看Google获得更多的细节。

你可能感兴趣的:(Kotlin 之 协程)

  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿 小鹿_33
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
  • 《大清方方案》| 第二话 谁佐清欢
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
  • 《庄子.达生9》 钱江潮369
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 2020-04-12每天三百字之连接与替代 冷眼看潮
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
  • 东南林氏之九牧林候选父系 祖缘树TheYtree
    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
  • 大伟说成语之唉声叹气 求索大伟
    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • 怎么做淘客赚钱(2022最新免费淘客盈利的方法) 高省_飞智666600
    很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 锁之缘 尘缘诗词原创作品
    是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • ARM驱动学习之4小结 JT灬新一 嵌入式C++arm开发学习linux
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • 2020-12-24 我和我的天使们
    阅读《老子的心事》391—403“将欲取之，必固与之”：想要得到什么，首先就要送出什么。我常常对孩子们说，你希望别人怎样对你你就怎样对待别人。想要得到别人的尊重，首先要尊重别人。我希望她们可以不迟到，因为不迟到是对别人的尊重，我就自己就先做到不迟到。哪怕是约朋友逛街，我尽量准时赴约。我严格要求孩子们，也同样严格要求自己，我跟孩子们一起把好的品格变成习惯。“是谓微明”：这就是微妙的智慧。看起来很少很
  • 18、架构-可观测性之聚合度量 大树~~ 架构javapython后端架构
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
  • 学习“论语”-第59天 春峰轩
    12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
  • 2021-11-15 宙火
    我给宋小姐写了首诗，是我在课上因思恋宋小姐而写的。“自古多情是唐宋，从来双飞归巢燕。邻家小女相聘婷，常使春意荡漾我。不知单思可为爱，惟愿一心付之汝。”我拿给宋小姐看了，她说我写得很棒。我很开心，但又不是那么开心。宋小姐是回复我了，但也只是说我写得很棒，对我诗句中蕴藏的真切感情，不知道是真的没发现，还是装作没发现。但我不深究，只是这样，我就很开心了。我答应宋小姐，一天给她写一首诗。
  • 《我的青葱岁月之缘来是你》 第二章 迎新晚会 思源思缘思怨
    “怎么你也来了这里？”我愉快的问到，想着这是上天给的缘分吗？我还没去找他竟然就相遇了。那个让我开心的老乡。“你好，我也是舞蹈社的新人啊！”他说，笑起来回答我，眼睛弯弯的。“这么巧，我叫吴倩，你叫啥？”“我叫韩欢，你也是B市人吧，c中毕业的？”“我不是，我是f中的，不然肯定会认识你的”“是吗？以后多多关照了”他还冲我眨了眨眼睛。内心一阵悸动，这是……回到寝室，我兴奋的告诉我的室友这个事情，我再次觉得
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • 厦门自由行之第一天: 大苏子在广漂
    厦门三人行之杂记出发前一天:12️28日下午15:00从广州粗发，来深圳集合！但是中间发生一个小插曲，验票时候发现车票不见了，或许也是一场恶作剧，对于不排队的人，忍不住说了一下，接下来就发现车票不见了，已经是拿在手上！不过还好，可以凭借购票订单查看到信息，所以有惊无险，顺利进站！晚上三个人一起去吃了柠檬鱼，说实话，那会，感觉美吃饱，啊哈哈！晚上回来，两个人又开始彻夜长谈，发现身边优秀的人，一大把，
  • “这才好”麻辣香锅 能够增加人身体的免疫能力 小补文知
    我就来介绍一种香锅，那就是“这才好”麻辣香锅，它产出于著名的蜀地文化，具有悠久的历史土家风味，麻辣鲜香，健康安全。采用传统秘制麻辣香锅油辣子，还有贴心加料“孜然包”满足人们的不同口味需求，香锅底料辣椒，微辣且香，含有丰富微量元素和维生素，具有辣而不躁，味道纯正，醇厚温和。花椒采用历史悠久，被列为宫廷供品的“贡椒”的汉源花椒。我们还挑选了“川菜之魂”郫县豆瓣的鼻祖品牌豆瓣，保留最原始的郫县豆瓣味道，
  • 《太虚游》第六十二章。玄牝之威。 古楼臭道士
    “好好好，流云这孩子深得我心，想必长爻知道是你的话定然会惊喜不已的。”白玄牝听得风流云应了下来，脸色慈和，伸手在他头顶轻轻抚了抚，如同抚在怀中九尾小狐一样自然，极其温柔。身后的四位青丘长老同时一怔，嘴角微动，似要开口劝阻。风流云只感到一道霞光瑞气如有实质一般顺着头顶百会大穴直沉在下丹田内，随后这股气息又逐渐凝聚，似乎给自己吃了什么东西一般。啊喔不好，这祖奶奶该不会是看中我这肉身，像人魔一样，要给她
  • 生命如花 坦释空
    每个人的心中都有一株妙莲花。这是禅家语。禅家总是站在理性的高处，以超越红尘的洒脱来参悟人生和自省生命。那么，凡俗中人呢？生如夏花之绚丽，死如秋叶之静美。这是诗人语。多少人在赞美：姑娘好像花一样！又有多少人在咏歌：花儿与少年。的确，人生如花。花一样的生命，理应自诞生之日起，就一瓣一瓣地绽放她的美丽与清香，使这个原本死寂荒凉的世界五彩缤纷，充满快乐。事实上，人类自诞生起，就一代一代地做着这方面的努力，
  • 二婚到底是领证好还是不领证好？ 孟妃青
    伟人讲过，不以结婚为目的的谈恋爱，都是耍流氓！离婚了，再找对象，感情到了一定程度，领证结婚是水到渠成的事，再说我中华泱泱大国，有礼仪之邦的称谓，领证更是体现了尊重男女双方的行为。如果认为二婚就没必要领证了，只能说明，男女之间都暗藏心思，心不往一处走，日子过不好的。即便他们感情再深，都不是合法夫妻，只是名不正言不顺的同居关系。假如不要二人共同的孩子还好，就怕有了孩子，没领证，到时给孩子上户口都成问题
  • 《华杉讲透王阳明传习录》 微微微微神
    〔5〕希渊问：“圣人可学而至。然伯夷伊尹于孔子，才力终不同。其同谓之圣者安在”？先生曰，“圣人之所以为圣，只是其心纯乎天理，而无人欲之杂。犹精金之所以为精，但以其成色足而无铜铅之杂也。人到纯乎天理方是圣。金到足色方是精。然圣人之才力，亦有大小不同。犹金之分两有轻重。尧舜犹万镒。文王孔子犹九千镒。禹汤武王犹七八千镒。伯夷伊尹犹四五千镒。才力不同，而纯乎天理则同。皆可谓之圣人。犹分两虽不同，而足色则同
  • “日舍一物”之42——活在当下，并向前看 記二十一
    这件衣服已经有十五、六年了（突然发现我可真是能囤东西啊）。这原本是一件我非常喜欢的衣服，无论是样子，还是质地。照片拍的比较渣，但其实，白色棉质衣料中，尚织有银色的丝线，在阳光或灯光下，会闪亮，不晃眼，但很漂亮。或许正是因为太喜欢了，所以一直保留着，尽管很多年都没有再穿过了。因为不合适了。首先是随着年龄的增长，尽管体重总量没有太多变化（哦，其实还是涨了）。但是体型还是和十几年前不一样了，最明显的就是
  • 语文主题教学学习笔记之87 东哥杂谈
    “语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
  • tomcat基础与部署发布 暗黑小菠萝 Tomcat java web
    从51cto搬家了，以后会更新在这里方便自己查看。 做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。 一、Tomcat安装     安装方式：①运行.exe安装包      &n
  • 网站架构发展的过程 ayaoxinchao 数据库应用服务器网站架构
    1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
  • [信息与安全]数据库的备份问题 comsci 数据库
          如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题   如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢?    是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢?  &n
  • 使用maven tomcat plugin插件debug关联源代码 商人shang mavendebug查看源码tomcat-plugin
    *首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 *配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
  • 大访问量高并发 oloz 大访问量高并发
    大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简 要列出几点解决方案： 01、优化你的代码和查询语句，合理使用索引 02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 03、采用服务器集群、负载均衡分担大访问量高并发压力 04、数据读写分离 05、合理选用框架，合理架构(推荐分布式架构)。
  • cache 服务器 小猪猪08 cache
    Cache   即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。 　　1.Cache   是怎么样工作的? 　　Cache   是分配在服务器上
  • mysql存储过程 香水浓 mysql
    Description:插入大量测试数据 use xmpl; drop procedure if exists mockup_test_data_sp; create procedure mockup_test_data_sp( in number_of_records int ) begin declare cnt int; declare name varch
  • CSS的class、id、css文件名的常用命名规则 agevs JavaScriptUI框架Ajaxcss
      CSS的class、id、css文件名的常用命名规则     (一)常用的CSS命名规则 　　头：header 　　内容：content/container 　　尾：footer 　　导航：nav 　　侧栏：sidebar 　　栏目：column 　　页面外围控制整体布局宽度：wrapper 　　左右中：left right
  • 全局数据源 AILIKES javatomcatmysqljdbcJNDI
    实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
  • MYSQL的随机查询的实现方法 baalwolf mysql
    MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
  • JAVA的getBytes()方法 bijian1013 javaeclipseunixOS
        在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！      String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： byte[] b_gbk = "
  • AngularJS中操作Cookies bijian1013 JavaScriptAngularJSCookies
            如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。         幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
  • [Maven学习笔记五]Maven聚合和继承特性 bit1129 maven
    Maven聚合   在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块： 1. 模型和数据持久化层user-core, 2. 业务逻辑层user-service以 3. web展现层user-web， user-service依赖于user-core user-web依赖于user-core和use
  • 【JVM七】JVM知识点总结 bit1129 jvm
      1. JVM运行模式 1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler
  • linux下查看nginx、apache、mysql、php的编译参数 ronin47
    在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 1、nginx [root@361way ~]# /App/nginx/sbin/nginx -V nginx: nginx version: nginx/
  • unity中运用Resources.Load的方法？ brotherlamp unity视频unity资料unity自学unityunity教程
    问：unity中运用Resources.Load的方法？ 答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 1、unity实时替换的物体即是依据环境条件
  • 线段树-入门 bylijinnan java算法线段树
    /** * 线段树入门 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i] * * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18 * @author lijinna
  • 全选与反选 chicony 全选
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>全选与反选</title>
  • vim一些简单记录 chenchao051 vim
    mac在/usr/share/vim/vimrc linux在/etc/vimrc   1、问：后退键不能删除数据，不能往后退怎么办？       答：在vimrc中加入set backspace=2   2、问：如何控制tab键的缩进？       答：在vimrc中加入set tabstop=4 (任何
  • Sublime Text 快捷键 daizj 快捷键sublime
    [size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
  • php 引用(&)详解 dcj3sjt126com PHP
    在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址 变量的引用 PHP 的引用允许你用两个变量来指向同一个内容  复制代码代码如下: <?  $a="ABC";  $b =&$a;  echo
  • SVN中trunk,branches,tags用法详解 dcj3sjt126com SVN
    Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
  • 对软件设计的思考 e200702084 设计模式数据结构算法ssh活动
    软件设计的宏观与微观    软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
  • 同步、异步、阻塞、非阻塞 geeksun 非阻塞
    同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。   同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。 场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。   异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。 实现：
  • Reverse SSH Tunnel 反向打洞實錄 hongtoushizi ssh
    實際的操作步驟： # 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port ssh -NfR 12345:localhost:22 [email protected] # 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器 ssh localhost -p 1
  • Hibernate中的缓存 Josh_Persistence 一级缓存Hiberante缓存查询缓存二级缓存
    Hibernate中的缓存   一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
  • 对象关系行为模式之延迟加载 home198979 PHP架构延迟加载
    形象化设计模式实战     HELLO!架构   一、概念 Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。 延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。     二、实现延迟加载 实现Lazy Load主要有四种方法：延迟初始化、虚
  • xml 验证 pengfeicao521 xmlxml解析
    有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 public static void testPattern() { // 含有非法字符的串 String str =       "Jamey&#52828;&#01;&#02;&#209;&#1282
  • div设置半透明效果 spjich css半透明
    为div设置如下样式：   div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;}        说明： 1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
  • 你真的了解单例模式么？ w574240966 java单例设计模式jvm
        单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。   一，单例模式的5中写法。（回字的四种写法，哈哈。）     1，懒汉式           （1）线程不安全的懒汉式 public cla
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他