小编Mar*_*nik的帖子

这段代码:

fun main() {
    runBlocking {
        try {
            val deferred = async { throw Exception() }
            deferred.await()
        } catch (e: Exception) {
            println("Caught $e")
        }
    }
    println("Completed")
}

结果输出:

Caught java.lang.Exception
Exception in thread "main" java.lang.Exception
    at org.mtopol.TestKt$main$1$deferred$1.invokeSuspend(test.kt:11)
    ...

这种行为对我没有意义.异常被捕获并处理,但它仍然作为未处理的异常逃到顶层.

这种行为是否有记录和预期？它违反了我对异常处理如何工作的所有直觉.

我从Kotlin论坛的一个帖子中改编了这个问题.

Kotlin文档建议使用,supervisorScope如果我们不想在一个失败时取消所有协同程序.所以我可以写

fun main() {
    runBlocking {
        supervisorScope {
            try {
                launch {
                    delay(1000)
                    println("Done after delay")
                }
                val job = launch {
                    throw Exception()
                }
                job.join()
            } catch (e: Exception) {
                println("Caught $e")
            } …

我有一个课程项目

class Item {
  public int count;
  public Item(int count) {
    this.count = count;
  }
}

然后,我将在其他类的字段中引用Item

class Holder {
  public Item item;
  public Holder() {
    item = new Item(50);
  }
}

这个新的Item对象可以安全发布吗？如果没有,为什么？根据Java Concurrency in Practice,新的Item是在没有完全构造的情况下发布的,但在我看来,新的Item是完全构造的:它的this引用不会被转义,并且它的引用和它的状态同时发布,所以消费者线程不会看到过时的价值.或者是可见性问题.我不知道原因.

我正在进行一个2d游戏/模拟,其中行星由围绕恒星的核心轨道周围的块组成.它们也会自行旋转,它们围绕恒星的旋转和它们的个人旋转都具有随机的速度.

该程序记录光线何时击中哪个块,并且它们的温度随着时间的推移而变化.它还根据温度随时间不同地对块进行着色.热块看起来更红,冷块看起来更蓝.

在下面的屏幕截图中,两颗行星都围绕恒星逆时针旋转轨道,顺时针旋转.左/下行星缓慢旋转,而顶/右行星旋转得更快.我将它们称为行星A(图1-3中的左/下)和行星B(图1-3中的右/上).

第一个截图是在启动程序后尽可能快地拍摄的:

行星A发展得非常快(并且保留了)一个梯度,显示出一整天都在阳光下一侧的温暖块,以及黎明刚刚升起的寒冷块.行星B移动得如此之快,似乎没有真正的温度差异可以发展.

大约一分钟后拍摄了第二张和第三张截图,并且相隔只有几秒钟才能更好地展示星球B上奇怪的"条带":

从观看它旋转开始,B行星似乎已经形成了永久冷和永久热的一面,尽管其快速(和理论上均匀)旋转.

如果有足够的时间,似乎所有的行星都采用这种奇怪的条带,其中一侧是热的,一侧是冷的,无论旋转如何.

(在上面的截图中,进一步说明,行星A位于右侧,行星B位于中间位置.)

而最奇怪的部分是,如果我让它运行更长时间,大多数行星采用行星A最初显示的合理模式,而有些行星继续奇怪的条带模式.

我有一个包含4个字段的表:

id,int(11),auto increament email,varchar(32)pass,varchar(32)date_created,date

我的问题是我的查询应该是什么样的？我的意思是我不需要将第一个值插入id,因为它是自动增量但我必须插入所有的值..

我试图从csv文件读取,但由于它的大小,没有首先将它全部加载到内存中.

我找到的用于阅读csv的库是opencsv,它工作得非常好,但只暴露了两种方法:

readAll() 

和

readNext() 

readAll因为我不想在内存中同时使用所有内容,所以我想通过lazily从文件中读取来readNext.理想情况下,我想通过一个流来结束阅读.

我得到的最接近的是将readnext方法赋予Stream.generate构造,

Stream csvDataStream = Stream.generate(csvReader::readNext); 

但是,一旦迭代器底层csvReader耗尽,这显然会导致抛出错误.我真的不想将我的整个程序包装在try/catch块中,因为我使用的是错误的语言.有没有办法从只暴露next方法的东西创建流？

我的应用程序非常庞大,例如在web-inf/lib中包含310个jar,总共100Mb.启动服务器,此步骤需要13秒:

Sep 16, 2014 1:05:33 PM org.apache.catalina.startup.HostConfig deployDirectory
INFO: Deploying web application directory C:\apache-tomcat-7.0.47\webapps\ROOT

应用程序依赖于Web片段和注释来正确启动.

我尝试了以下内容以跳过13s扫描时间:

• 修改 conf/context.xml with attribute logEffectiveWebXml="true"

• catalina run 2> web-complete.log

• 从中提取web.xml片段web-complete.log,将其保存在下webapps\ROOT\web-inf\web.xml

如果我开始申请,我仍然会看到13秒的扫描时间.在上面的snipet中,metadata-complete已经设置为"true".

将以下语句添加到web.xml后,完全跳过13s,但这次我的应用程序无法再启动:

<absolute-ordering />

1)在我的情况下,使tomcat快速启动的正确方法是什么？

2)你能解释为什么元数据完整对13s没有帮助吗？

3)Altough我的web.xml完成​​后,为什么不允许应用程序启动？

谢谢,

在kotlinx.coroutines库中,所有协同构建器(如launch,async等)都接受CoroutineContext参数,但也有parent一个类型为的附加参数Job.CoroutineContext和之间有什么区别Job？

我有Kotlin界面

interface FileSystem {
    suspend fun getName(path: Path): List<String>
}

我怎么能用Java调用它？什么是

Continuation <? super List<String>>

我在与协程一起玩耍，发现一些非常奇怪的行为。我想使用转换项目中的一些异步请求suspendCoroutine()。这是显示此问题的代码。

在第一种情况下，当在runBlocking协程中调用suspend函数时，来自延续的异常进入catch块，然后runBlocking成功完成。但是在第二种情况下，当创建新的async协程时，异常会通过catch块并使整个程序崩溃。

package com.example.lib

import kotlinx.coroutines.async
import kotlinx.coroutines.runBlocking
import kotlin.coroutines.resumeWithException
import kotlin.coroutines.suspendCoroutine

object Test {
    fun runSuccessfulCoroutine() {
        runBlocking {
            try {
                Repository.fail()
            } catch (ex: Throwable) {
                println("Catching ex in runSuccessfulCoroutine(): $ex")
            }
        }
    }

    fun runFailingCoroutine() {
        runBlocking {
            try {
                async { Repository.fail() }.await()
            } catch (ex: Throwable) {
                println("Catching ex in runFailingCoroutine(): $ex")
            }
        }
    }
}

object Repository {
    suspend fun fail(): Int = suspendCoroutine { cont …

对于使用异步API的任何人来说，这都是一个痛苦的熟悉问题：当您的调用遇到故障时，异步库的私有线程会检测到它，创建一个异常对象，并将其传递给您的回调。值得一毛钱的唯一信息就是该消息及其类型。堆栈跟踪毫无价值。

与Google Play报告应用程序崩溃的方式混杂在一起：消息被剥离，而您得到的只是堆栈跟踪。现在，您已一无所有。您只知道您的应用程序存在您在自己的测试中未检测到的错误。

Kotlin的协程至少给我们一些希望，可以将其做得更好。协程堆栈跟踪在概念上在那里，只是很难提取。但是，当前我们获得的堆栈跟踪与我上面描述的相同，没有用。

我熟悉kotlinx-coroutines-debug模块，并且在实现方面有一些规定可以重新创建协程堆栈跟踪，但是如何在用户智能手机上安装的生产应用程序中利用这些功能？