了解Vert.x:事件循环

让Vert.x框架实现高度可扩展和高性能的核心是事件循环,更具体地说是Multi-Reactor模式,以及它的消息总线,在Vert.x中称为EventBus。

在本文中,我想解决有关事件循环的误解,例如:

“Vert.x有EventLoop,所以它是单线程的,只使用一个CPU”?

要么

“Vert.x是多线程的,所以它必须为每个Verticle创建一个线程”?

Multi-Reactor

Event Loop是Reactor设计模式的一个实现。

它的目标是不断检查新事件,并在每次新事件发生时,快速将其发送给知道如何处理它的人。

但是通过仅使用一个线程来消费所有事件,我们基本上没有充分利用我们的硬件。例如,Node.js应用程序通常会生成多个进程来解决该问题。

在提供良好隔离的同时,进程也很昂贵。Vert.x使用多个线程,这在系统资源方面更便宜点。

为了理解Multi-Reactor在实践中的工作原理,我们将通过简单的调用来检查线程的数量 Thread.activeCount(),虽然不准确,但这足以满足我们的目的。

让我们先看看我们在程序开头有多少线程:

Before starting VertX -> 1 thread

现在我们将启动Vert.x应用程序:

Vertx vertx = Vertx.vertx();

再次检查线程数:

After starting VertX -> 3 threads

因此,启动Vert.x会产生2个额外的线程。一个是运行应用程序,另一个是调用vertx-blocked-thread-checker

现在让我们部署一千个Verticle,看看它如何影响我们的线程数。Verticle是轻量级的actor,通常在事件循环上运行。

<b>final</b> Map<String, AtomicInteger> threadCounts = <b>new</b> ConcurrentHashMap<>();

<b>int</b> verticles = 1000;
<b>final</b> CountDownLatch latch = <b>new</b> CountDownLatch(verticles);
<b>for</b> (<b>int</b> i = 0; i < verticles; i++) {
    vertx.deployVerticle(<b>new</b> MyVerticle(threadCounts), c -> latch.countDown());
}
latch.await();

threadCounts现在不要理会,因为它将在后面解释。

我们在这里使用CountDownLatch,因为Verticle是异步部署的,我们希望确保在检查线程数时已经部署了所有实例

After deploying 1000 verticles -> 19 threads

之前我们有3个线程,现在又增加了16个线程。它们都以形式命名vert.x-eventloop-thread-X。您可以启动一万个Verticle,并且不会影响事件循环线程的数量。

到目前为止,有两个重要的要点:

  • Vert.x不是单线程的
  • 事件循环线程的最大数量取决于CPU的数量,而不是部署的Verticle数量

您可以在此处查看默认线程数:

https://github.com/eclipse/vert.x/blob/master/src/main/java/io/vertx/core/VertxOptions.java#L38

现在是时候看看我们的Verticle是什么样的,为什么我们传递HashMap给它:

<b>class</b> MyVerticle <b>extends</b> AbstractVerticle {
    <b>private</b> <b>final</b> Map<String, AtomicInteger> threadCounts;

    MyVerticle(Map<String, AtomicInteger> threadCounts) {
        <b>this</b>.threadCounts = threadCounts;
    }

    @Override
    <b>public</b> <b>void</b> start() {
        threadCounts.computeIfAbsent(Thread.currentThread().getName(),
                t -> <b>new</b> AtomicInteger(0)).incrementAndGet();
    }
}

因此,当每个Verticle启动时,它会记录已分配的线程。

代码有助于我们了解如何在Verticle之间划分线程:

vert.x-eventloop-thread-0=125

vert.x-eventloop-thread-1=125

vert.x-eventloop-thread-2=125

vert.x-eventloop-thread-3=125

vert.x-eventloop-thread-4=125

vert.x-eventloop-thread-5=125

vert.x-eventloop-thread-6=125

vert.x-eventloop-thread-7=125

如您所见,每个新Verticle以循环方式获取一个线程。

查看结果您可能想知道,为什么我们部署了16个事件循环线程,但Verticle仅在前8个中注册。原因是我们非常积极地部署Verticle。在常规应用程序中,您可能不会这样做。

所以,让我们放松一下。我们将部署相同的千个Verticle,但这一次,一个接一个:

<b>private</b> <b>void</b> deployMyVerticle(<b>final</b> Vertx vertx,
                              <b>final</b> Map<String, AtomicInteger> threadCounts,
                              <b>final</b> AtomicInteger counter,
                              <b>final</b> <b>int</b> verticles) {
    vertx.deployVerticle(<b>new</b> MyVerticle(threadCounts), c -> {
        <b>if</b> (counter.incrementAndGet() < verticles) {
            deployMyVerticle(vertx, threadCounts, counter, verticles);
        }
    });
}

结果是我们使用的线程比以前少:

vert.x-eventloop-thread-0 = 250

vert.x-eventloop-thread-1 = 250

vert.x-eventloop-thread-2 = 250

vert.x-eventloop-thread-3 = 250

那是因为框架有足够的时间来做出反应。

Worker Verticle

worker verticle用于执行长时间运行或阻塞任务。让我们现在以类似的方式部署一千个worker Verticle,看看会发生什么:

<b>final</b> CountDownLatch workersLatch = <b>new</b> CountDownLatch(verticles);
<b>final</b> DeploymentOptions worker = <b>new</b> DeploymentOptions().setWorker(<b>true</b>);
<b>for</b> (<b>int</b> i = 0; i < verticles; i++) {
    vertx.deployVerticle(<b>new</b> MyVerticle(threadCounts), worker, c -> workersLatch.countDown());
}
workersLatch.await();

线程数:

After deploying 1000 worker verticles -> 27 threads

部署一千个worker  Verticle增加了另外20个线程。

这是因为工作者Verticle使用一个单独的线程池,默认情况下大小为20。

https://github.com/eclipse/vert.x/blob/master/src/main/java/io/vertx/core/VertxOptions.java#L43

您可以通过调用VertxOptions的setWorkerPoolSize()on 来控制此池的大小,然后在Vert.x初始化时传递它们:

<b>final</b> VertxOptions options = <b>new</b> VertxOptions().setWorkerPoolSize(10);
Vertx vertx = Vertx.vertx(options);

请注意,与常规Verticle不同,worker Verticle不会在线程之间均匀分布,因为它们用于不同的目的:

vert.x-worker-thread-0=126

vert.x-worker-thread-1=39

vert.x-worker-thread-2=94

vert.x-worker-thread-3=118

vert.x-worker-thread-4=89

vert.x-worker-thread-5=114

vert.x-worker-thread-6=222

vert.x-worker-thread-7=79

vert.x-worker-thread-8=67

vert.x-worker-thread-9=50

可以类似的方式控制事件循环池的大小:

<b>final</b> VertxOptions options = <b>new</b> VertxOptions().setEventLoopPoolSize(4);
Vertx vertx = Vertx.vertx(options);

结论

以下是几个要点:

  • Vert.x是多线程框架
  • 它使用受控数量的线程
  • 对于事件循环任务,默认情况下,线程池的大小是CPU计数的两倍
  • 对于worker任务,默认情况下线程池的大小为20
  • 可以轻松调整两个线程池的大小

原文 

https://www.jdon.com/50911

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 了解Vert.x:事件循环

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址