SupKing_a520
SupKing_a520

Kotlin语言（十三）：Flow

注：本文中使用 runBlocking 是为了方便测试，业务开发中禁止使用

一、Flow 的基本使用

1、Sequence 序列生成器

（1）取出序列生成器中的值，需要迭代序列生成器；
（2）是同步调用，是阻塞的，无法调用其它的挂起函数。

fun sequenceFun() {
    val sequence = sequence {
        Thread.sleep(1000)
        yield(1)
        Thread.sleep(1000)
        yield(2)
        Thread.sleep(1000)
        yield(3)
    }
    sequence.forEach {
        println(it)
    }
    println("Done!")

    // 1
    // 2
    // 3
    // Done!
}

2、Flow 的简单使用

（1）flow{ ... } 内部可以调用 suspend 函数；
（2）使用 emit() 方法来发射数据；
（3）使用 collect() 方法来收集结果。

fun flowFun() = runBlocking {
    val flow = flow {
        delay(1000)
        emit(1)
        delay(1000)
        emit(2)
        delay(1000)
        emit(3)
    }
    flow.collect {
        println(it)
    }
    println("Done!")

    // 1
    // 2
    // 3
    // Done!
}

3、创建 Flow 的常用方式

（1）flow{...} 需要显示调用 emit() 发射数据；
（2）flowOf() 一个发射固定值集的流, 不需要显示调用 emit() 发射数据；
（3）asFlow() 扩展函数，可以将各种集合与序列转换为流，也不需要显示调用 emit() 发射数据。

fun createFlowFun() = runBlocking {
    val flow1 = flow {
        delay(1000)
        emit(1)
    }
    val flow2 = flowOf(2, 3).onEach {
        delay(1000)
    }
    val flow3 = listOf(4, 5).asFlow().onEach {
        delay(1000)
    }
    flow1.collect {
        println(it)
    }
    flow2.collect {
        println(it)
    }
    flow3.collect {
        println(it)
    }
    println("Done!")

    // 1
    // 2
    // 3
    // 4
    // 5
    // Done!
}

4、Flow 是冷流（惰性的）

如同 Sequences 一样， Flow 也是惰性的，即在调用末端流操作符( collect 是其中之一)之前，flow{ ... } 中的代码不会执行。我们称之为 -- 冷流。

fun coldFlowFun() = runBlocking {
    val flow = flowOf(1, 2, 3)
        .onEach {
            delay(1000)
        }
    println("calling collect...")
    flow.collect {
        println(it)
    }
    println("calling collect again...")
    flow.collect {
        println(it)
    }

    // calling collect...
    // 1
    // 2
    // 3
    // calling collect again...
    // 1
    // 2
    // 3
}

5、Flow 的取消

流采用了与协程同样的协助取消，取消 Flow 只需要取消它所在的 协程 即可。

fun cancelFlowFun() = runBlocking {
    val flow = flow {
        for (i in 1..3) {
            delay(100)
            println("Emitting $i")
            emit(i)
        }
    }
    withTimeoutOrNull(250) {
        flow.collect {
            println(it)
        }
    }
    println("Done!")

    // Emitting 1
    // 1
    // Emitting 2
    // 2
    // Done!
}


二、Flow 的常用操作符

1、末端流操作符 collect 、reduce 、fold、toxxx 等

fun terminalFlowOptFun() = runBlocking {
    val flow = (1..3).asFlow().onEach { delay(200) }
    flow.collect { println(it) }
    // 1
    // 2
    // 3

    val reduceSum = flow.reduce { a, b -> a + b }
    println("reduce: sum = $reduceSum")
    // reduce: sum = 6

    val foldSum = flow.fold(100) { a, b -> a + b }
    println("fold: sum = $foldSum")
    // fold: sum = 106

    val list = flow.toList()
    val set = flow.toSet()
    println("list: $list")
    println("set: $set")
    // list: [1, 2, 3]
    // set: [1, 2, 3]

    val flow2 = flowOf("one", "two").onEach { delay(200) }
    flow.onEach { println(it) }.launchIn(this)
    flow2.onEach { println(it) }.launchIn(this)
    // 1
    // one
    // 2
    // two
    // 3
}

2、流启动时 onStart

fun startFlowFun() = runBlocking {
    (1..3).asFlow()
        .onEach { delay(1000) }
        .onStart { println("onStart") }
        .collect { println(it) }

    // onStart
    // 1
    // 2
    // 3
}

3、流完成时 onCompletion

（1）使用 try ... finally 实现；
（2）通过 onCompletion 函数实现。

fun completionFlowFun() = runBlocking {
    try {
        flow {
            for (i in 1..3) {
                delay(1000)
                emit(i)
            }
        }.collect {
            println(it)
        }
    } finally {
        println("Done!")
    }
    // 1
    // 2
    // 3
    // Done!

    flow {
        for (i in 1..3) {
            delay(1000)
            emit(i)
        }
    }.onCompletion { println("Done!") }
        .collect { println(it) }
    // 1
    // 2
    // 3
    // Done!
}

4、背压 Backpressure

Backpressure 是响应式编程的功能之一，Flow 的 Backpressure 是通过 suspend 函数实现的。
（1）buffer 缓冲（这里要注意的是，buffer 的容量是从 0 开始计算的）
   - SUSPEND 设置缓冲区，如果溢出了，则将当前协程挂起，直到有消费了缓冲区中的数据；
   - DROP_LATEST 设置缓冲区，如果溢出了，丢弃最新的数据；
   - DROP_OLDEST 设置缓冲区，如果溢出了，丢弃最老的数据。
（2）conflate 合并
   - 不设缓冲区，也就是缓冲区大小为 0，采取 DROP_OLDEST 策略，等价于 buffer(0, BufferOverflow.DROP_OLDEST) 。

fun bufferFlowFun() = runBlocking {
    val cosTime = measureTimeMillis {
        (1..5).asFlow()
            .onEach {
                delay(100)
                println("produce data: $it")
            }
            .buffer(1, BufferOverflow.SUSPEND)
            .collect {
                delay(500)
                println("collect: $it")
            }
    }
    println("cosTime: $cosTime")

    // produce data: 1
    // produce data: 2
    // produce data: 3
    // collect: 1
    // produce data: 4
    // collect: 2
    // produce data: 5
    // collect: 3
    // collect: 4
    // collect: 5
    // cosTime: 2742
}

fun conflateFlowFun() = runBlocking {
    val cosTime = measureTimeMillis {
        (1..5).asFlow()
            .onEach {
                delay(100)
                println("produce data: $it")
            }
            .conflate()
            .collect {
                delay(500)
                println("collect: $it")
            }
    }
    println("cosTime: $cosTime")

    // produce data: 1
    // produce data: 2
    // produce data: 3
    // produce data: 4
    // produce data: 5
    // collect: 1
    // collect: 5
    // cosTime: 1223
}

5、Flow 异常处理 catch、retry、retryWhen

（1）catch 操作符捕获上游异常
   - onCompletion 用来处理 Flow 是否收集完成，即使是遇到异常也会执行；
   - onCompletion 有一个参数可以用来判断上游是否出现异常；上游出现异常，不为 null，未出现异常，则为 null；
   - onCompletion 只能判断是否出现了异常，并不能捕获异常；
   - 捕获异常使用 catch 操作符；
   - 如果把 onCompletion 和 catch 交换一下位置，则 catch 操作捕获到异常之后，不会再影响下游；
   - catch 操作符用于实现异常透明化处理, catch 只是中间操作符不能捕获下游的异常；
   - catch 操作符内，可以使用 throw 再次抛出异常、可以使用 emit() 转换为发射值、可以用于打印或者其他业务逻辑的处理等等。
（2）retry、retryWhen 操作符重试
   - 如果上游遇到了异常，并且 retry 方法返回 true 则会进行重试，最多重试 retries 指定的次数;
   - retry 最终调用的是 retryWhen 操作符。

fun catchFlowFun() = runBlocking {
    (1..5).asFlow()
        .onEach {
            if (it == 4) {
                throw Exception("test exception")
            }
            delay(100)
            println("produce data: $it")
        }
        /*.catch { e ->
            println("catch exception: $e")
        }*/
        .onCompletion { e ->
            if (null == e) {
                println("onCompletion")
            } else {
                println("onCompletion: $e")
            }
        }
        .catch { e ->
            println("catch exception: $e")
        }
        .collect {
            println("collect: $it")
        }

    // produce data: 1
    // collect: 1
    // produce data: 2
    // collect: 2
    // produce data: 3
    // collect: 3
    // onCompletion: java.lang.Exception: test exception
    // catch exception: java.lang.Exception: test exception
}

fun retryFlowFun() = runBlocking {
    (1..5).asFlow()
        .onEach {
            if (it == 2) {
                throw Exception("test exception")
            }
            delay(100)
            println("produce data: $it")
        }
        .retry(1) {
            it.message == "test exception"
        }
        /*.retryWhen { cause, attempt ->
            cause.message == "test exception" && attempt < 1
        }*/
        .catch { ex ->
            println("catch exception: ${ex.message}")
        }
        .collect {
            println("collect: $it")
        }

    // produce data: 1
    // collect: 1
    // produce data: 1
    // collect: 1
    // catch exception: test exception
}

6、Flow 线程切换 flowOn

（1）响应线程是由 CoroutineContext 决定的，比如，在 Main 线程中执行 collect， 那么响应线程就是 Dispatchers.Main；
（2）Flow 通过 flowOn 方法来切换线程，多次调用，都会影响到它上游的代码。

fun switchThreadFlowFun() = runBlocking {
    val myDispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
    (1..2).asFlow()
        .onEach {
            printlnWithThread("produce data: $it")
        }
        .flowOn(Dispatchers.IO)
        .onEach {
            printlnWithThread("IO data: $it")
        }
        .flowOn(myDispatcher)
        .onEach {
            printlnWithThread("my data: $it")
        }
        .flowOn(Dispatchers.Default)
        .onCompletion {
            myDispatcher.close()
        }
        .collect {
            printlnWithThread("collect: $it")
        }

    // Thread -> id: 12, name: DefaultDispatcher-worker-2, produce data: 1
    // Thread -> id: 12, name: DefaultDispatcher-worker-2, produce data: 2
    // Thread -> id: 13, name: pool-1-thread-1, IO data: 1
    // Thread -> id: 13, name: pool-1-thread-1, IO data: 2
    // Thread -> id: 11, name: DefaultDispatcher-worker-1, my data: 1
    // Thread -> id: 11, name: DefaultDispatcher-worker-1, my data: 2
    // Thread -> id: 1, name: main, collect: 1
    // Thread -> id: 1, name: main, collect: 2
}

7、Flow 的中间转换操作符

（1）map 操作符用于将流中的每个元素进行转换后再发射出来

fun mapFlowFun() = runBlocking {
    (1..2).asFlow()
        .map {
            "map -> $it"
        }
        .collect {
            println(it)
        }

    // map -> 1
    // map -> 2
}

（2）transform 操作符，可以任意多次调用 emit ，这是 transform 跟 map 最大的区别

fun transformFlowFun() = runBlocking {
    (1..2).asFlow()
        .transform {
            emit("transform1 -> $it")
            delay(100)
            emit("transform2 -> $it")
        }
        .collect {
            println(it)
        }

    // transform1 -> 1
    // transform2 -> 1
    // transform1 -> 2
    // transform2 -> 2
}

（3）onEach 遍历

fun onEachFlowFun() = runBlocking {
    (1..3).asFlow()
        .onEach { println("onEach: $it") }
        .collect { println(it) }

    // onEach: 1
    // 1
    // onEach: 2
    // 2
    // onEach: 3
    // 3
}

（4）filter 条件过滤

fun filterFlowFun() = runBlocking {
    (1..5).asFlow()
        .filter { it % 2 == 0 }
        .collect { println(it) }

    // 2
    // 4
}

（5）drop 过滤掉 前 N 个 元素

fun dropFlowFun() = runBlocking {
    (1..5).asFlow()
        .drop(3)
        .collect { println(it) }

    // 4
    // 5
}

（6）dropWhile 过滤 满足条件 的 前 N 个 元素，一旦条件不满足则不再过滤后续元素

fun dropWhileFlowFun() = runBlocking {
    listOf(1, 3, 4, 2, 5).asFlow()
        .dropWhile { it < 4 }
        .collect { println(it) }
    // 4
    // 2
    // 5

    listOf(1, 3, 4, 2, 5).asFlow()
        .dropWhile { it % 2 == 1 }
        .collect { println(it) }
    // 4
    // 2
    // 5
}

（7）take 只取 前 N 个 emit 发射的值

fun takeFlowFun() = runBlocking {
    (1..5).asFlow()
        .take(2)
        .collect { println(it) }

    // 1
    // 2
}

（8）takeWhile 只取 满足条件 的 前 N 个 元素，一旦条件不满足则不再获取后续元素

fun takeWhileFlowFun() = runBlocking {
    (5 downTo 1).asFlow()
        .takeWhile { it > 3 }
        .collect { println(it) }

    // 5
    // 4

    listOf(5, 2, 4, 1).asFlow()
        .takeWhile { it > 3 }
        .collect { println(it) }

    // 5
}

（9）zip 是可以将2个 flow 进行合并的操作符
   - 即使 flowB 中的每一个 item 都使用了 delay() 函数，在合并过程中也会等待 delay() 执行完后再进行合并；
   - 如果 flowA 和 flowB 中 item 个数不一致，则合并后新的 flow item 个数，等于较小的 item 个数。

fun zipFlowFun() = runBlocking {
    val flowA = (1..6).asFlow()
    val flowB = flowOf("one", "two", "three").onEach { delay(200) }
    flowA.zip(flowB) { a, b -> "$a and $b" }
        .collect { println(it) }

    // 1 and one
    // 2 and two
    // 3 and three
}

（10）combine 合并时，组合每个流最新发出的元素

fun combineFlowFun() = runBlocking {
    val flowA = (1..5).asFlow().onEach { delay(100) }
    val flowB = flowOf("one", "two", "three", "four", "five").onEach { delay(200) }
    flowA.combine(flowB) { a, b -> "$a and $b" }.collect { println(it) }

    // 1 and one
    // 2 and one
    // 3 and one
    // 3 and two
    // 4 and two
    // 5 and two
    // 5 and three
    // 5 and four
    // 5 and five
}

（11）flattenConcat 将给定流按顺序展平为单个流，而不交错嵌套流

fun flattenConcatFlowFun() = runBlocking {
    val flowA = (1..3).asFlow()
    val flowB = flowOf("a", "b", "c").onEach { delay(1000) }
    flowOf(flowA, flowB).flattenConcat().collect { println(it) }

    // 1
    // 2
    // 3
    // a
    // b
    // c
}

（12）fattenMerge 有一个参数，并发限制，默认 16；参数必须大于0，为 1 时，等价于 flattenConcat

fun flattenMergeFlowFun() = runBlocking {
    val flowA = (1..3).asFlow().onEach { delay(1000) }
    val flowB = flowOf("a", "b", "c").onEach { delay(2000) }
    flowOf(flowA, flowB).flattenMerge(8).collect { println(it) }

    // 1
    // a
    // 2
    // 3
    // b
    // c
}

（13）flatMapContact 由 map、flattenConcat 操作符实现，收集新值之前会等待 flatMapConcat 内部的 flow 完成

fun flatMapContactFlowFun() = runBlocking {
    (1..2).asFlow()
        .flatMapConcat {
            flow {
                emit(it)
                delay(1000)
                emit("string: $it")
            }
        }
        .collect {
            println(it)
        }

    // 1
    // string: 1
    // 2
    // string: 2
}

（14）flatMapMerge 由 map、flattenMerge 操作符实现，不会等待内部的 flow 完成

fun flatMapMergeFlowFun() = runBlocking {
    (1..2).asFlow()
        .flatMapMerge {
            flow {
                emit(it)
                delay(1000)
                emit("string: $it")
            }
        }
        .collect {
            println(it)
        }

    // 1
    // 2
    // string: 1
    // string: 2
}

（15）flatMapLatest 当发射了新值之后，上个 flow 就会被取消

fun flatMapLatestFlowFun() = runBlocking {
    (1..3).asFlow()
        .onEach { delay(100) }
        .flatMapLatest {
            flow {
                println("begin flatMapLatest: $it")
                delay(200)
                emit("string: $it")
                println("end flatMapLatest: $it")
            }
        }
        .collect { println(it) }
}


三、StateFlow 和 SharedFlow

StateFlow 和 SharedFlow 是用来替代 BroadcastChannel 的新的 API。用于上游发射数据，能同时被 多个订阅者 收集数据。

1、StateFlow

（1）StateFlow 是一个状态容器式可观察数据流，可以向其收集器发出当前状态更新和新状态更新；还可通过其 value 属性读取当前状态值；
（2）StateFlow 有两种类型: StateFlow（只读） 和 MutableStateFlow（可以改变 value 的值）；
（3）StateFlow 的状态由其值表示，任何对值的更新都会反馈新值到所有流的接收器中；
（4）StateFlow 发射的数据可以被在不同的协程中的多个接受者同时收集；
（5）StateFlow 是热流，只要数据发生变化，就会发射数据；
（6）StateFlow 调用 collect 收集数据后不会停止，需要手动取消订阅者的协程；
（7）StateFlow 只会发射最新的数据给订阅者。

class StateFlowTest {
    private val _state = MutableStateFlow("unKnow")
    val state: StateFlow get() = _state

    fun getApi1(scope: CoroutineScope) {
        scope.launch {
            delay(1000)
            _state.value = "hello StateFlow"
        }
    }

    fun getApi2(scope: CoroutineScope) {
        scope.launch {
            delay(1000)
            _state.value = "hello Kotlin"
        }
    }
}

fun stateFlowFun() = runBlocking {
    val test = StateFlowTest()
    test.getApi1(this)
    delay(1000)
    test.getApi2(this)

    val job1 = launch(Dispatchers.IO) {
        delay(5000)
        test.state.collect {
            printlnWithThread(it)
        }
    }
    val job2 = launch(Dispatchers.IO) {
        delay(5000)
        test.state.collect {
            printlnWithThread(it)
        }
    }

    delay(7000)
    job1.cancel()
    job2.cancel()

    // Thread -> id: 11, name: DefaultDispatcher-worker-1, hello Kotlin
    // Thread -> id: 13, name: DefaultDispatcher-worker-3, hello Kotlin
}

2、SharedFlow

（1）SharedFlow 管理一系列状态更新(即事件流)，而非管理当前状态；
（2）SharedFlow 也有两种类型：SharedFlow 和 MutableSharedFlow；
   - SharedFlow 包含可用作原子快照的 replayCache，每个新的订阅者会先从 replay cache 中获取值，然后才收到新发出的值；
   - MutableSharedFlow 可用于从挂起或非挂起的上下文中发射值，顾名思义，可以重置 replayCache，而且还将订阅者的数量作为 Flow 暴露出来。
（3）MutableSharedFlow 具有 subscriptionCount 属性，其中包含处于活跃状态的收集器的数量；
（4）MutableSharedFlow 包含一个 resetReplayCache 函数，在不想重放已向数据流发送的最新信息的情况下使用；
（5）使用 sharedIn 方法可以将 Flow 转换为 SharedFlow

class SharedFlowTest {
    private val _state = MutableSharedFlow(
        replay = 2,                               // 当新的订阅者 Collect 时，发送几个已经发送过的数据给它
        extraBufferCapacity = 3,                  // 减去 replay 还缓存多少数据（即此处总缓存为5）
        onBufferOverflow = BufferOverflow.SUSPEND // 缓存溢出时的处理策略，三种 丢掉最新值、丢掉最旧值和挂起
    )
    val state: SharedFlow get() = _state

    fun getApi(scope: CoroutineScope) {
        scope.launch {
            for (i in 0..5) {
                delay(200)
                _state.emit(i)
                printlnWithThread("send data: $i")
            }
        }
    }
}

fun sharedFlowFun() = runBlocking {
    val test = SharedFlowTest()
    test.getApi(this)

    val job = launch(Dispatchers.IO) {
        delay(1000)
        test.state.collect {
            printlnWithThread("collect data: $it")
        }
    }

    delay(5000)
    job.cancel()

    // 总缓存为5，订阅时先发送2个旧数据，然后再收集新数据
    // Thread -> id: 1, name: main, send data: 0
    // Thread -> id: 1, name: main, send data: 1
    // Thread -> id: 1, name: main, send data: 2
    // Thread -> id: 1, name: main, send data: 3
    // Thread -> id: 11, name: DefaultDispatcher-worker-1, collect data: 2
    // Thread -> id: 11, name: DefaultDispatcher-worker-1, collect data: 3
    // Thread -> id: 1, name: main, send data: 4
    // Thread -> id: 11, name: DefaultDispatcher-worker-1, collect data: 4
    // Thread -> id: 1, name: main, send data: 5
    // Thread -> id: 11, name: DefaultDispatcher-worker-1, collect data: 5
}

你可能感兴趣的:(Kotlin语言（十三）：Flow)

  • 小丽成长记（四十三） 玲玲54321
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
  • 每日一题——第八十三题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • 三人行（六十三） 清风不等明月
    书接上文：虽然大家都认为要进密室看看，但是罗道长还是提醒各位不要轻举妄动。让灵儿这两天也不用在盯着孟琦了，罗道长想从侧面打探一下密室的消息，看看有没有办法把孟琦调走一段时间，这样就有机会进入密室查看了。机会很快就来了，因为月底孟琦要在议事堂商议各堂口的事项。所以有一天的时间他的卧室都是空的。这一天很快就到了，各堂口的负责人都聚集在议事堂，今天孟琦是主角，他当然也是不能缺席的。他们商议的无非是各堂口
  • 【2021-01-24】人生十三信条 wc的一些事一些情
    23:59一个人应当有良好的礼貌来突出他特有的天性。人人都喜欢出人头地，但这不应当引起别人的讨厌。——歌德1、节制：食不可过饱，饮不得过量。2、缄默：避免无谓闲扯，言谈必须对人有益。3、秩序：生活物品要放置有序，工作时间要合理安排。4、决心：要做的事就下决心去做，决心做的事一定要按时完成。5、节俭：不奢侈浪费，任何花费都要做到有益，不论是于人，还是于己。6、勤勉：珍惜每一刻时间，去除一切不必要之举
  • 《我的职业是小说家》 simple梦
    《我的职业是小说家》：《我的职业是小说家》是村上春树前所未有的自传性作品，历时六年完成。一个人，写作三十五年，十三部长篇小说，超过五十种语言译本。虽然拥有享誉世界的知名度，但关于村上春树，许多事情始终包裹在神秘的面纱中：他是怎样下定决心走上职业小说家之路？对他来说，人生中幸福的事是什么？究竟如何看待芥川奖与诺贝尔文学奖……小说家看似风光，却是份孤独的职业。三十五年来，村上春树在孤独中编织着美妙动人
  • 乱说话 要承担后果 余生要幸福888
    平日里，我们说话一定要特别注意，有些话是万万不能说的，会很灵验的！当说了不该说的话后，可能引发的后果，将是你始料不及的！01乱说话遭遇“鬼打墙”几年前，我认识的一个客户给我讲了一段他的亲身经历：他们公司在北京十三陵附近的一个度假村召开公司年会，会期三天。会议的第二天下午，他和另外两个朋友临时回市区办点事。等到办完事往回赶，快到度假村时，天已经接近傍晚了。车里三个人一路走一路闲聊，其中一个人就突然感
  • 晨间日记 时光分拣机
    一日一诗赠别（一）唐-杜牧娉娉袅袅十三余，豆蔻梢头二月初。春风十里扬州路，卷上珠帘总不如。https://mp.weixin.qq.com/s/DRQzfcPvFkcGBBOR06PbEw图片发自App
  • 十一今日套圈，神了 二十八亩甜
    10//8℃阴腊月二十三今天是老妈的生日，醒来第一件事就是给老妈发生日红包，顺便看看前几天买的生日礼物到没，结果要明天老爸过生才能收到，还好给二老都买了，要不我爸以为只有我妈的，会吃醋的，哈哈哈哈。让十一给外婆说生日快乐，十一依然不会说。今天的十一还是有记录的点。和多多姐姐一起玩反斗乐园，看到姐姐一进来就和姐姐来了个大大的拥抱，后来还和一个刚学会走路的妹妹也来了个大大拥抱，结果两小只直接抱到侧翻了
  • css设置当字数超过限制后以省略号（...）显示 周bro css前端vuecss3html经验分享
    1、文字超出一行，省略超出部分，显示’…’用text-overflow:ellipsis属性来，当然还需要加宽度width属来兼容部分浏览。overflow:hidden;text-overflow:ellipsis;white-space:nowrap;2、多行文本溢出显示省略号display:-webkit-box;-webkit-box-orient:vertical;-webkit-lin
  • 史上最全git命令,git回滚,git命令大全 騒周 其他git
    git命令大全一、Git整体理解二、由暂存区本地仓库三、由本地仓->远程仓库四、冲突处理五、Git分支操作六、bug的分支七、feature分支八、暂存的使用九、远程仓的操作十、标签的使用十一、Git配置全局信息十二、Linux的一些简单操作和一些符号的解释十三、符号解释十四、显示安装详细信息十五、gitconfig十六、Gitclone十七、Gitinit十八、gitstatus十九、gitre
  • 婴童医话（二百一十三） 妙手柯楠
    探天地清浊之源，察阴阳顺逆之机。实热吐痰，虚极霍乱，伤食面黄，神昏爱眠，食伤脾胃。啼而不哭，烦也，肺有风也；哭而不啼，躁也，肝经病也。惊自热来，痫因痰致，惊本心生，风由肝起。乳食伤胃，则为吐呕；乳食伤脾，则为泄泻。吐泻既久则成慢惊，或为疳病。乳食停积，则生湿痰，痰则生火，痰火交作，则成急惊，或为喉痹。痰火结滞，则成痫吊，或为喘嗽。
  • 前端CSS面试常见题 剑亦未配妥 前端面试前端css面试
    边界塌陷盒模型有两种：W3C盒模型和IE盒模型，区别在于宽度是否包含边框定义：同时给兄弟/父子盒模型设置上下边距，理论上边距值是两者之和，实际上不是注意：浮动和定位不会产生边界塌陷；只有块级元素垂直方向才会产生margin合并margin计算方案margin同为正负：取绝对值大的值一正一负：求和父子元素边界塌陷解决父元素可以通过调整padding处理；设置overflowhidden，触发BFC子
  • 《相面天师》第六百四十三章 死在你前面 先峰老师
    说实话，安东尼马库斯的进攻套路虽然很简单，来来去去就是左右腿的侧踢。但是经过千万次的训练，安东尼马库斯已经将这扫腿练得炉火纯青，就是这简单的侧踢，最少带给李尚鸿三次以上致命的威胁。交战了大约有七八分钟的时间了，安东尼马库斯时而像是西伯利亚的猛虎，大开大合硬拼硬打，时而又像是狐狸一般，数次都逃过了李尚鸿的致命一击。虽然也对安东尼马库斯造成了一些伤害，但至今为止，李尚鸿也未能找到一击毙敌的机会，可是眼
  • 财富自由之路读书笔记2 Elaine_a963
    继续财富自由读书笔记，今天就第十-二十三章进行归纳总结思考。这本书可以说是边学边练的武功秘籍。秘籍一：注意力。先从认知上刷新，先前谈到价值的重要性及单位价值提升的必要性。这里就引出了：“注意力”是在任何地方“挖掘”价值的最基本工具。那么，要自如运用注意力，就得练习。这里李老师给的无他，就是基本功训练扎实-坐享。秘籍二：活在未来。再一次颠覆认知，大众的思维是活在当下，而这里指引我们要活在未来。用正确
  • 【原创小说】总是东风错丨第十三章 郭勒的鱼
    郑重声明：文章系原创非首发，首发平台：头条号，ID：郭勒的鱼，文责自负。天刚亮，府外面一片嘈杂，门被拍的山响，这一夜苏府惊魂，人们吓得如同惊弓之鸟，听到这敲门声，连苏福都不敢贸然开门。趴在门缝往外一看，是大太太的哥哥舅姥爷虞南基来了，连忙着人开门，不但是虞南基来了，还领来一队三十多个全副武装的士兵。南竹看着哥哥。嘴扁了扁，蓦然鼻子一酸哭得泣不成声，虞南基很诧异。他这个妹妹他了解，外表的柔婉其实都是
  • 【连载】左手梅里，右手雨崩·入藏十三线纯徒日记 杉道
    徒步进藏日记·滇藏线篇DAY124－125起点：木许乡入口中点：佛山乡终点：溜筒江村距离：48KM日期：2021.01.12-2021.01.13佛山乡2021.01.12·····原文链接：杉道·····昨夜雨疏风骤，淡睡难消囿困。夜半一阵锁链拖地的细碎声响由远及近、飘忽不定，路灯已暗，周围一片寂静，遂想起恐怖片里杀人碎尸的一些镜头，总觉得锁链那头是一柄被紧紧撰在手里的斧头，它的主人面带寒笑，与
  • 宋真宗御笔书名的“岳麓书院”，历经千年魅力永续 博物馆学文化
    中国古代书院，兴起于唐，清代诗人袁枚在《随园随笔》中记载：“书院之名起唐玄宗时，丽正书院、集贤书院皆建于朝省，为修书之地，非士子肄业之所也。”在《新唐书·百官志》中记载：“唐开元六年，将乾元院改为丽正修书院，十三年又改丽正修书院为集贤殿书院。”这是史料中有关书院最早的记载。是唐代为了搜集图书、校刊经籍，撰写文章的场所，而非教育机构，也非朝廷的正式办事机构。最早具有教育功能的书院是白鹿洞书院，与它一
  • 2022-04-28 换个昵称更好耍
    二十二年辛丑，公元前三八零年齐伐燕，取桑丘。魏、韩、赵伐齐，至桑丘。二十三年壬寅，公元前三七九年赵袭卫，不克。齐康公薨，无子，田氏遂并齐而有之。是岁，齐桓公亦薨，子威王因齐立。二十四年癸卯，公元前三七八年狄败魏师于澮。魏、韩、赵伐齐，至灵丘。晋孝公薨，子靖公俱酒立。二十五年甲辰，公元前三七七年蜀伐楚，取兹方。二十二年（辛丑，前380）1．齐国攻打燕国，占领桑丘。魏、韩、赵三国联合攻打齐国，大兵到达
  • 【读史明智098】论语系列之八十三 希音无问西东
    8.18：子曰：“巍巍乎！舜禹之有天下也而不与焉。”8.19：子曰：“大哉尧之为君也！巍巍乎！唯天为大，唯尧则之。荡荡乎！民无能名焉。巍巍乎其有成功也，焕乎其有文章！”原句译文8.18孔子说：“舜、禹真伟大！他们从不以拥有天下为傲，依然能踏实地做事。”8.19孔子说：“尧当君主，伟大崇高，可比于天！他的恩德，无法形容！他的功劳，千古留芳！他的制度，光辉灿烂！”有天下也而不与：名利压不垮真正的大佬孔
  • 《灵动碎片战记》【第一季】第二十三话——颖饼生病了（下） Mint思
    楠玖:“医生，烁韩她怎么样了。”医生:“这孩子情况不太妙，她呀，胃绞痛，你们留下一个人陪床。”余温:“我留下来吧！你们都回去吧。”若离:“不行，我们和你一起，颖饼生病了，我们是一个团队，必须一起。”樱花:“对呀，怎么可能丢下你们两个人不管呢？”云雀:“行了，你们都别吵了，就这样，我们都留下来，轮流陪床，我妈是医生，我还懂点儿这方面的知识，反正这是单间病房，有床的，今晚我来看着，你们都睡吧。”无奈，
  • 【霜天晓角】中秋方去 冯素萍
    霜天晓角中秋方去文/冯素萍中秋方去，来送萧萧雨。一夜身凉风弄，园枝瑟，多几许。情郁。起缕缕。万千伤心绪。肠断怀萦欲发，笺辞忘，椎管举。霜天晓角，词牌名。上依双调四十三字，前段五句三仄韵，后段六句四仄韵林逋体。
  • 《论语·子路第十三》14：冉有为什么成了受气包 花石冈
    《论语·子路第十三》14：冉有为什么成了受气包冉子退朝，子曰：“何晏也？”对曰：“有政。”子曰：“其事也？如有政，虽不吾以，吾其与闻之。”冉有下班后来拜望先生，先生说：怎么下班这么晚？冉有回答道：因为有国政要处理。先生说：怕是季氏的家事吧？如有国政，如今我虽不见用，也不至于连听闻都听闻不到吧！这里的这个“冉子”，用得很是莫名其妙。一般情况下，诸弟子但凡和孔子呆在一起，记录时便不会用到这个表示尊称的
  • 劳动使我快乐（四上） 宁静与幸福
    通过我的努力终于可以和奶奶去打扫小区了！奶奶先带我到了二十三楼-顶楼，一开始我还有点恐高，但过了一会儿就好多了，最后根本不怕了，这才让我安心了！这时奶奶说：“我来擦玻璃门，你来擦窗户。”我想：“简单，不就是擦窗户嘛！我一定会擦干净的！”于是我就开始了，首先用喷雾喷一喷，然后刮刀刮一刮。咦！怎么回事？上面怎么还有泡沫？奶奶笑道：“傻孩子，像你这样左边一下，右边一下，上一下，下面一下，能擦干净才怪！要
  • 随笔之六十三 hh1895
    今天大宝哭了，觉得那么突然，让我心疼。虽然他说没什么，但是我知道他的失落。于是我耐心跟他讲解为什么在小宝快睡着的时候一定要安静，不能突然想到什么就跑来告诉我，可以等小家伙睡熟之后再详细的说。为什么小家伙被吵醒之后会更加难哄，为什么爸爸妈妈在他被吵醒后会有那种无奈的表情。但是当我告诉他他自己当年的表现以及当时全家对于他的小心翼翼时，大宝便释怀了。对于孩子来说，自身的经历比较具有说服力。无论是家长还是
  • 华杉版资治通鉴【1963】讨伐吴元济。2023-06-26 华杉2009
    4、五月十九日，桂王李纶薨逝。5、六月二十七日，任命河中节度使张弘靖为刑部尚书，同平章事。张弘靖，是张延赏之子。6、翰林学士独孤郁，是权德舆的女婿。皇上感叹独孤郁的才华，说：“权德舆能得到独孤郁这样的女婿，我反而不如他吗！”之前选择驸马，都在贵戚及勋臣之家，现在，皇上开始命宰相在公卿、大夫子弟中选择文雅可以担任清闲显贵官职的，诸家多不情愿，惟独杜佑的孙子、司议郎杜悰不推辞。秋，七月二十三日，任命杜
  • 一手好字的第四十三天 自信的姐姐
    网络图片，侵权必删世事洞明皆学问，透过表象看本质！我知道了自己的短板：基本功字之控笔能力，而解决之道，除了练无它！好吧，既如此，那就按原先的计划执行，时间我有，总能挤出来的，不够就跟老天再借五百年呗！就不信，学不好母语写不好字！无论是啥想法，但节奏不乱，每天该干啥还干啥，不因基本功烂就多练，非也！心急吃不了热豆腐，更何况是练字？练字要的是耐心、天天练、细细品、慢慢改！人会撒谎但字不会，付出了会看得
  • 《论语·公冶长》之十三 - 朱文津 让世界因我的存在而更加美好
    《论语·公冶长》之十三朱文津各位同学大家好！今天我们学习《公冶长篇》第十三章，先恭诵原文——子贡曰：“夫子之文章，可得而闻也；夫子之言性与天道，不可得而闻也。”子贡说：“夫子讲的知识学问，是可以听到的；夫子讲的性与天道，是难得听到的。”所依一：宋代大儒程颢(hào)、程頣（yí）认为：“此子贡闻夫子之至论而叹美之言也。”这是圣门高徒子贡，赞叹夫子讲的性与天道太美了，再没有比这个更高深微妙的道理了。
  • jvm调优总结（从基本概念 到 深度优化） oloz javajvmjdk虚拟机应用服务器
    JVM参数详解：http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html   Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
  • 【Scala十六】Scala核心十：柯里化函数 bit1129 scala
    本篇文章重点说明什么是函数柯里化，这个语法现象的背后动机是什么，有什么样的应用场景，以及与部分应用函数(Partial Applied Function)之间的联系   1. 什么是柯里化函数 A way to write functions with multiple parameter lists. For instance def f(x: Int)(y: Int) is a
  • HashMap dalan_123 java
    HashMap在java中对很多人来说都是熟的；基于hash表的map接口的非同步实现。允许使用null和null键；同时不能保证元素的顺序；也就是从来都不保证其中的元素的顺序恒久不变。 1、数据结构     在java中，最基本的数据结构无外乎：数组 和 引用（指针），所有的数据结构都可以用这两个来构造，HashMap也不例外，归根到底HashMap就是一个链表散列的数据
  • Java Swing如何实时刷新JTextArea，以显示刚才加append的内容 周凡杨 java更新swingJTextArea
    在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。 问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现
  • servlet或struts的Action处理ajax请求 g21121 servlet
    其实处理ajax的请求非常简单，直接看代码就行了： //如果用的是struts //HttpServletResponse response = ServletActionContext.getResponse(); // 设置输出为文字流 response.setContentType("text/plain"); // 设置字符集 res
  • FineReport的公式编辑框的语法简介 老A不折腾 finereport公式总结
    FINEREPORT用到公式的地方非常多，单元格（以=开头的便被解析为公式），条件显示，数据字典，报表填报属性值定义，图表标题，轴定义，页眉页脚，甚至单元格的其他属性中的鼠标悬浮提示内容都可以写公式。 简单的说下自己感觉的公式要注意的几个地方：   1.if语句语法刚接触感觉比较奇怪，if(条件式子,值1,值2)，if可以嵌套，if(条件式子1，值1，if(条件式子2，值2，值3)
  • linux mysql 数据库乱码的解决办法 墙头上一根草 linuxmysql数据库乱码
    linux 上mysql数据库区分大小写的配置 lower_case_table_names=1 1-不区分大小写 0-区分大小写   修改/etc/my.cnf 具体的修改内容如下:   [client] default-character-set=utf8   [mysqld] datadir=/var/lib/mysql socket=/va
  • 我的spring学习笔记6-ApplicationContext实例化的参数兼容思想 aijuans Spring 3
    ApplicationContext能读取多个Bean定义文件，方法是： ApplicationContext appContext = new ClassPathXmlApplicationContext（ new String[]｛“bean-config1.xml”，“bean-config2.xml”，“bean-config3.xml”，“bean-config4.xml
  • mysql 基准测试之sysbench annan211 基准测试mysql基准测试MySQL测试sysbench
    1 执行如下命令，安装sysbench-0.5： tar xzvf sysbench-0.5.tar.gz  cd sysbench-0.5  chmod +x autogen.sh  ./autogen.sh  ./configure --with-mysql --with-mysql-includes=/usr/local/mysql
  • sql的复杂查询使用案列与技巧 百合不是茶 oraclesql函数数据分页合并查询
      本片博客使用的数据库表是oracle中的scott用户表;          -------------------  自然连接查询           查询 smith 的上司(两种方法) &
  • 深入学习Thread类 bijian1013 javathread多线程java多线程
    一．             线程的名字 下面来看一下Thread类的name属性，它的类型是String。它其实就是线程的名字。在Thread类中，有String getName()和void setName(String)两个方法用来设置和获取这个属性的值。 同时，Thr
  • JSON串转换成Map以及如何转换到对应的数据类型 bijian1013 javafastjsonnet.sf.json
            在实际开发中，难免会碰到JSON串转换成Map的情况，下面来看看这方面的实例。另外，由于fastjson只支持JDK1.5及以上版本，因此在JDK1.4的项目中可以采用net.sf.json来处理。 一.fastjson实例 JsonUtil.java package com.study; impor
  • 【RPC框架HttpInvoker一】HttpInvoker：Spring自带RPC框架 bit1129 spring
    HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成   在 【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中
  • 【Mahout二】基于Mahout CBayes算法的20newsgroup的脚本分析 bit1129 Mahout
    #!/bin/bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information re
  • nginx三种获取用户真实ip的方法 ronin47
    随着nginx的迅速崛起，越来越多公司将apache更换成nginx. 同时也越来越多人使用nginx作为负载均衡, 并且代理前面可能还加上了CDN加速，但是随之也遇到一个问题：nginx如何获取用户的真实IP地址,如果后端是apache,请跳转到<apache获取用户真实IP地址>，如果是后端真实服务器是nginx，那么继续往下看。 实例环境： 用户IP 120.22.11.11
  • java-判断二叉树是不是平衡 bylijinnan java
    参考了 http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 但是用java来实现有一个问题。 由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass import ljn.help.*; public class BalancedBTree {
  • BeanUtils.copyProperties VS PropertyUtils.copyProperties 诸葛不亮 PropertyUtilsBeanUtils
     BeanUtils.copyProperties VS  PropertyUtils.copyProperties  作为两个bean属性copy的工具类，他们被广泛使用，同时也很容易误用，给人造成困然；比如：昨天发现同事在使用BeanUtils.copyProperties copy有integer类型属性的bean时，没有考虑到会将null转换为0，而后面的业
  • [金融与信息安全]最简单的数据结构最安全 comsci 数据结构
          现在最流行的数据库的数据存储文件都具有复杂的文件头格式，用操作系统的记事本软件是无法正常浏览的，这样的情况会有什么问题呢？        从信息安全的角度来看，如果我们数据库系统仅仅把这种格式的数据文件做异地备份，如果相同版本的所有数据库管理系统都同时被攻击，那么
  • vi区段删除 Cwind linuxvi区段删除
    区段删除是编辑和分析一些冗长的配置文件或日志文件时比较常用的操作。简记下vi区段删除要点备忘。   vi概述    引文中并未将末行模式单独列为一种模式。单不单列并不重要，能区分命令模式与末行模式即可。   vi区段删除步骤： 1. 在末行模式下使用:set nu显示行号 非必须，随光标移动vi右下角也会显示行号，能够正确找到并记录删除开始行
  • 清除tomcat缓存的方法总结 dashuaifu tomcat缓存
    用tomcat容器，大家可能会发现这样的问题，修改jsp文件后，但用IE打开 依然是以前的Jsp的页面。 出现这种现象的原因主要是tomcat缓存的原因。 解决办法如下: 在jsp文件头加上 <meta http-equiv="Expires" content="0"> <meta http-equiv="kiben&qu
  • 不要盲目的在项目中使用LESS CSS dcj3sjt126com Webless
    　如果你还不知道LESS CSS是什么东西，可以看一下这篇文章，是我一朋友写给新人看的《CSS——LESS》 　　不可否认，LESS CSS是个强大的工具，它弥补了css没有变量、无法运算等一些“先天缺陷”，但它似乎给我一种错觉，就是为了功能而实现功能。 　　比如它的引用功能 ? .rounded_corners{     
  • [入门]更上一层楼 dcj3sjt126com PHPyii2
    更上一层楼 通篇阅读完整个“入门”部分，你就完成了一个完整 Yii 应用的创建。在此过程中你学到了如何实现一些常用功能，例如通过 HTML 表单从用户那获取数据，从数据库中获取数据并以分页形式显示。你还学到了如何通过 Gii 去自动生成代码。使用 Gii 生成代码把 Web 开发中多数繁杂的过程转化为仅仅填写几个表单就行。 本章将介绍一些有助于更好使用 Yii 的资源：
  • Apache HttpClient使用详解 eksliang httpclienthttp协议
    Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
  • zxing二维码扫描功能 gundumw100 androidzxing
    经常要用到二维码扫描功能 现给出示例代码 import com.google.zxing.WriterException; import com.zxing.activity.CaptureActivity; import com.zxing.encoding.EncodingHandler; import android.app.Activity; import an
  • 纯HTML+CSS带说明的黄色导航菜单 ini htmlWebhtml5csshovertree
    HoverTree带说明的CSS菜单:纯HTML+CSS结构链接带说明的黄色导航   在线体验效果：http://hovertree.com/texiao/css/1.htm代码如下,保存到HTML文件可以看到效果：   <!DOCTYPE html > <html > <head> <title>HoverTree
  • fastjson初始化对性能的影响 kane_xie fastjson序列化
    之前在项目中序列化是用thrift，性能一般，而且需要用编译器生成新的类，在序列化和反序列化的时候感觉很繁琐，因此想转到json阵营。对比了jackson，gson等框架之后，决定用fastjson，为什么呢，因为看名字感觉很快。。。   网上的说法：   fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。
  • 基于Mybatis封装的增删改查实现通用自动化sql mengqingyu DAO
    1.基于map或javaBean的增删改查可实现不写dao接口和实现类以及xml，有效的提高开发速度。 2.支持自定义注解包括主键生成、列重复验证、列名、表名等 3.支持批量插入、批量更新、批量删除 <bean id="dynamicSqlSessionTemplate" class="com.mqy.mybatis.support.Dynamic
  • js控制input输入框的方法封装(数字，中文，字母，浮点数等) qifeifei javascript js
    在项目开发的时候，经常有一些输入框，控制输入的格式，而不是等输入好了再去检查格式，格式错了就报错，体验不好。 /** 数字，中文，字母,浮点数(+/-/.) 类型输入限制，只要在input标签上加上 jInput="number,chinese,alphabet,floating" 备注：floating属性只能单独用*/     funct
  • java 计时器应用 tangqi609567707 javatimer
    mport java.util.TimerTask;   import java.util.Calendar;   public class MyTask extends TimerTask {        private static final int
  • erlang输出调用栈信息 wudixiaotie erlang
    在erlang otp的开发中，如果调用第三方的应用，会有有些错误会不打印栈信息，因为有可能第三方应用会catch然后输出自己的错误信息，所以对排查bug有很大的阻碍，这样就要求我们自己打印调用的栈信息。用这个函数：erlang:process_display (self (), backtrace).需要注意这个函数只会输出到标准错误输出。 也可以用这个函数：erlang:get_s
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他