小编Yul*_*lin的帖子

假设我有以下代码:

CompletableFuture<Integer> future  
        = CompletableFuture.supplyAsync( () -> 0);

thenApply 案件:

future.thenApply( x -> x + 1 )
      .thenApply( x -> x + 1 )
      .thenAccept( x -> System.out.println(x));

这里输出为2.现在如下thenApplyAsync:

future.thenApplyAsync( x -> x + 1 )   // first step
      .thenApplyAsync( x -> x + 1 )   // second step
      .thenAccept( x -> System.out.println(x)); // third step

我在这个博客中读到,每个thenApplyAsync都是在一个单独的线程中执行,并且"同时"(这意味着thenApplyAsyncs在thenApplyAsyncs完成之前开始跟随),如果是这样,如果第一步没有完成,第二步的输入参数值是多少？

如果不采取第二步,第一步的结果会在哪里？第三步将采取哪一步的结果？

如果第二步必须等待第一步的结果那么重点是Async什么？

这里x - > x + 1只是为了表明这一点,我想知道的是在非常长的计算情况下.

在超类中，我有：

abstract someMethod() throws someException;

在子类中，我有：

someMethod(){/*do something*/}

无需throws someException声明就可以这样做吗？是不是该throws someException声明是有默认不明确增加了吗？

我有一个像这样的课:

class A{
    int a;
    int b;
    // a lot more properties...

    void methodA(){
       // very long method
    }
    void methodB(){
       // very long method
    }
    // a lot more methods...
}

有一次我需要序列化这个类的实例,并通过网络将它发送到另一个节点.在另一个节点上只需要属性,方法则不需要.由于通过网络发送数据是昂贵的,要轻量化我是否应该创建另一个中间类,如下所示去除所有方法并发送此类的序列化实例？

class A_{
    int a;
    int b;
    // copy all the properties in class A
}

我的项目需要大量的异步编程，所以我选择AKKA平台，因为使用actor模型可以像编写同步代码一样实现异步系统，而不必担心线程问题。一切正常，直到我遇到以下问题（演示代码）：

import akka.actor.AbstractActor;
import akka.japi.pf.ReceiveBuilder;
import java.util.concurrent.locks.ReentrantLock;

public class TestActor extends AbstractActor {
    private final ReentrantLock lock  = new ReentrantLock();

    @Override
    public Receive createReceive() {
        return ReceiveBuilder.create()
                .matchEquals("lock", s -> lock.lock())
                .matchEquals("unlock", s -> lock.unlock())
                .build();
    }
}

首先发送“锁定”消息，然后发送“解锁”消息，在收到发送消息后尝试解锁时，抛出了一个IllegalMonitorStateException，我发现这是由于不同的消息实际上由不同的线程处理，s -> lock.lock()并且s -> lock.unlock()是在不同的线程中执行，因此IllegalMonitorStateException抛出。

我之前的假设是，演员的所有操作都在一个线程中执行，因此它是完全线程安全的，不必担心线程问题。由于我在项目中广泛使用 AKKA，现在我非常担心并且不清楚第一剂在使用 AKKA 时何时需要考虑线程问题。例如，在以下演示代码中：

public class TestActor1 extends AbstractActor {
    private int count  = 0;
    private Map<Integer, Integer> map = new HashMap<>();
    
    @Override
    public Receive createReceive() {
        return ReceiveBuilder.create() …