Question

我想知道是否有人遇到过同样的问题。

我们有一个Vert.x应用程序，最终它的目的是在Cassandra集群中插入6亿行。我们通过少量测试来测试Vert.x与Cassandra结合的速度。

如果我们使用-cluster选项运行fat jar（使用Shade插件构建），我们可以在大约一分钟内插入1000万条记录。当我们添加-cluster选项（最终我们将在集群中运行Vert.x应用程序）时，需要大约5分钟才能插入1000万条记录。

有谁知道为什么？

我们知道Hazelcast配置会产生一些开销，但从未想过它会慢5倍。这意味着当使用没有集群选项的1 EC2时，集群中需要5个EC2实例才能获得相同的结果。

如上所述，一切都在EC2实例上运行：

t2.small上的2个Cassandra服务器
t2.2xlarge上的1个Vert.x服务器

Answer 1

您实际上遇到了Vert.x Hazelcast集群管理器的极端情况。

首先，您使用工作人员Verticle发送消息（30000001）。在引擎盖下，Hazelcast是阻塞的，因此当您从工作人员发送消息时，版本3.3.3不会考虑该问题。最近我们添加了这个修复https://github.com/vert-x3/issues/issues/75（不存在于3.4.0.Beta1中但存在于3.4.0-SNAPSHOTS中），这将改善这种情况。

第二，当您同时发送所有消息时，它会遇到阻止Hazelcast集群管理器使用集群拓扑缓存的另一个案例。此拓扑缓存通常在发送第一条消息后更新，并且一次性发送所有消息可防止使用疼痛（简短说明HazelcastAsyncMultiMap＃getInProgressCount将> 0并阻止缓存使用），因此支付昂贵的查找（因此缓存）的惩罚。

如果我使用带有3.4.0-SNAPSHOT + Hazelcast的Bertjan再现器并进行以下更改：向目的地发送消息，等待回复。在回复后发送所有消息然后我得到了很多改进。

没有聚类：5852毫秒使用HZ 3.3.3进行聚类：16745 ms 使用HZ 3.4.0-SNAPSHOT +初始消息进行聚类：8609 ms

我相信你也不应该使用worker verticle发送那么多消息，而是通过批处理使用事件循环verticle发送它们。也许您应该解释一下您的用例，我们可以考虑解决它的最佳方法。

Answer 2

当您为应用程序启用群集（任何类型）时，您使应用程序对故障更具弹性，但您也会增加性能损失。

例如，您当前的流程（没有聚类）类似于：

client -> 
  vert.x app -> 
    in memory same process eventbus (negletible) ->
    handler -> cassandra
  <- vert.x app
<- client

启用群集后：

client ->
  vert.x app ->
    serialize request ->
      network request cluster member ->
        deserialize request ->
          handler -> cassandra
        <- serialize response
      <- network reply
    <- deserialize response
  <- vert.x app
<- client

正如您所看到的，需要进行多次编码解码操作以及多次网络呼叫，这一切都会增加到您的总请求时间。

为了获得最佳性能，您需要利用本地性，您通常最快的数据存储距离。

Answer 3

只需添加项目代码即可。我想这会有所帮助。

发件人Verticle：

public class ProviderVerticle extends AbstractVerticle {

    @Override
    public void start() throws Exception {
        IntStream.range(1, 30000001).parallel().forEach(i -> {
        vertx.eventBus().send("clustertest1", Json.encode(new TestCluster1(i, "abc", LocalDateTime.now())));
        });
    }

    @Override
    public void stop() throws Exception {
        super.stop();
   }
}

插入器Verticle

public class ReceiverVerticle extends AbstractVerticle {

    private int messagesReceived = 1;

    private Session cassandraSession;

    @Override
    public void start() throws Exception {

        PoolingOptions poolingOptions = new PoolingOptions()
                .setCoreConnectionsPerHost(HostDistance.LOCAL, 2)
                .setMaxConnectionsPerHost(HostDistance.LOCAL, 3)
                .setCoreConnectionsPerHost(HostDistance.REMOTE, 1)
                .setMaxConnectionsPerHost(HostDistance.REMOTE, 3)
                .setMaxRequestsPerConnection(HostDistance.LOCAL, 20)
                .setMaxQueueSize(32768)
                .setMaxRequestsPerConnection(HostDistance.REMOTE, 20);

        Cluster cluster = Cluster.builder()
                .withPoolingOptions(poolingOptions)
                .addContactPoints(ClusterSetup.SEEDS)
                .build();

        System.out.println("Connecting session");
        cassandraSession = cluster.connect("kiespees");
        System.out.println("Session connected:\n\tcluster [" + cassandraSession.getCluster().getClusterName() + "]");
        System.out.println("Connected hosts: ");

        cassandraSession.getState().getConnectedHosts().forEach(host -> System.out.println(host.getAddress()));

        PreparedStatement prepared = cassandraSession.prepare(
                "insert into clustertest1 (id, value, created) " +
                        "values (:id, :value, :created)");

        PreparedStatement preparedTimer = cassandraSession.prepare(
                "insert into timer (name, created_on, amount) " +
                        "values (:name, :createdOn, :amount)");

        BoundStatement timerStart = preparedTimer.bind()
                .setString("name", "clusterteststart")
                .setInt("amount", 0)
                .setTimestamp("createdOn", new Timestamp(new Date().getTime()));
        cassandraSession.executeAsync(timerStart);

        EventBus bus = vertx.eventBus();

        System.out.println("Bus info: " + bus.toString());
        MessageConsumer<String> cons = bus.consumer("clustertest1");
        System.out.println("Consumer info: " + cons.address());

        System.out.println("Waiting for messages");

        cons.handler(message -> {
            TestCluster1 tc = Json.decodeValue(message.body(), TestCluster1.class);

            if (messagesReceived % 100000 == 0)
                System.out.println("Message received: " + messagesReceived);

            BoundStatement boundRecord = prepared.bind()
                    .setInt("id", tc.getId())
                    .setString("value", tc.getValue())
                    .setTimestamp("created", new Timestamp(new Date().getTime()));
            cassandraSession.executeAsync(boundRecord);

            if (messagesReceived % 100000 == 0) {
                BoundStatement timerStop = preparedTimer.bind()
                        .setString("name", "clusterteststop")
                        .setInt("amount", messagesReceived)
                        .setTimestamp("createdOn", new Timestamp(new Date().getTime()));
                cassandraSession.executeAsync(timerStop);
            }

            messagesReceived++;
            //message.reply("OK");
        });
    }

    @Override
    public void stop() throws Exception {
        super.stop();
        cassandraSession.close();
    }
}

使用-cluster选项

3 个答案: