Java Vertx：垂直通道空闲时的资源分配？

我对Vertx非常陌生，一直在我的应用程序中试用Vertx 3。到目前为止，它在某些场景中似乎非常有用。但我确实有一个问题，我想得到一个全面的答案，因为文档和谷歌没有提供任何信息

据我观察，在一个不使用集群vertx的简单应用程序中，每个部署的verticle都由一个单独的线程维护。但目前我的应用程序（即使用其他框架的web应用程序）并没有一直使用vertx（这意味着很多业务逻辑并不涉及vertx，部署的Verticle并不总是很忙，只以相对不频繁的方式执行操作）。我想知道在这个场景中，当垂直网格被部署但处于空闲状态时，vertx是否会释放线程，并且仅当它们接收到事件时才使用线程？或者它们会占用线程，而不允许应用程序的非vertx部分使用它们

---

提前感谢

事实上，这部分内容涵盖得很好：

Vert.x在这里的工作方式不同。不是单个事件循环，而是每个 Vertx实例维护几个事件循环。默认情况下，我们选择 数字基于机器上可用的磁芯数，但 可以重写

你错的地方是，绑定到一条线的垂直线是占据一条线的垂直线。假设您有4个CPU和1个竖轴。VertX将为其EventLoop分配4个线程。你从100个顶点开始？VertX仍将使用4个线程

但是，如果Verticle34在Thread2上启动，然后被挂起，它将始终在同一个线程上恢复

---

现在让我们看一些代码：

public class EventLoopExample {

static Map<String, AtomicInteger> threadCounts = new ConcurrentHashMap<>();

public static void main(String[] args) {
    printActive("Before starting VertX");

    Vertx vertx = Vertx.vertx();

    printActive("After starting VertX");
    for (int i = 0; i < 1000; i++) {
        vertx.deployVerticle(new MyVerticle());
        printActive("Regular verticle deployed");
    }

    printActive("Before deploying worker verticles");
    for (int i = 0; i < 1000; i++) {
        vertx.deployVerticle(new MyVerticle(), new DeploymentOptions().setWorker(true));
        printActive("Worker verticle deployed");
    }

    printActive("After everything deployed");

    System.out.println(new TreeMap(threadCounts));

    AtomicInteger count = new AtomicInteger(0);
    threadCounts.forEach((key, value) -> {
        count.addAndGet(value.get());
    });

    System.out.println(count.get());
}

private static void printActive(String message) {
    System.out.println(message);
    System.out.println(Thread.activeCount());
}

static class MyVerticle extends AbstractVerticle {

    @Override
    public void start() {
        threadCounts.putIfAbsent(Thread.currentThread().getName(), new AtomicInteger(0));
        threadCounts.get(Thread.currentThread().getName()).incrementAndGet();
    }

    @Override
    public void stop() throws Exception {
        System.out.println("Stopped");
    }
}
}

公共类事件循环示例{
静态映射线程计数=新的ConcurrentHashMap（）；
公共静态void main（字符串[]args）{
printActive（“启动VertX前”）；
Vertx Vertx=Vertx.Vertx（）；
printActive（“启动VertX后”）；
对于（int i=0；i<1000；i++）{
vertx.deployVerticle（新的MyVerticle（））；
printActive（“常规垂直部署”）；
}
printActive（“在部署工作竖梃之前”）；
对于（int i=0；i<1000；i++）{
deployVerticle（new MyVerticle（），new DeploymentOptions（）.setWorker（true））；
printActive（“工人垂直部署”）；
}
printActive（“部署一切后”）；
System.out.println（新树映射（线程计数））；
AtomicInteger计数=新的AtomicInteger（0）；
threadCounts.forEach（（键，值）->{
count.addAndGet（value.get（））；
});
System.out.println（count.get（））；
}
私有静态void printActive（字符串消息）{
System.out.println（消息）；
System.out.println（Thread.activeCount（））；
}
静态类MyVerticle扩展了AbstractVerticle{
@凌驾
公开作废开始（）{
putIfAbsent（Thread.currentThread（）.getName（），新的AtomicInteger（0））；
threadCounts.get（Thread.currentThread（）.getName（））.incrementAndGet（）；
}
@凌驾
public void stop（）引发异常{
系统输出打印项次（“停止”）；
}
}
}

注: 在VertX启动之前，有两个线程处于活动状态
即使您没有部署verticles，VertX的启动也会增加2个线程
EventLoop线程数由核心数定义。由于我有8个内核，VertX最多创建8个线程。
工作线程池默认为20个线程。

---

因此，除非您创建更多Workerpool或以任何其他方式使用配置，否则VertX不会使用超过32个线程。

事实上，这部分内容涵盖得很好：

Vert.x在这里的工作方式不同。不是单个事件循环，而是每个 Vertx实例维护几个事件循环。默认情况下，我们选择 数字基于机器上可用的磁芯数，但 可以重写

你错的地方是，绑定到一条线的垂直线是占据一条线的垂直线。假设您有4个CPU和1个竖轴。VertX将为其EventLoop分配4个线程。你从100个顶点开始？VertX仍将使用4个线程

但是，如果Verticle34在Thread2上启动，然后被挂起，它将始终在同一个线程上恢复

---

现在让我们看一些代码：

public class EventLoopExample {

static Map<String, AtomicInteger> threadCounts = new ConcurrentHashMap<>();

public static void main(String[] args) {
    printActive("Before starting VertX");

    Vertx vertx = Vertx.vertx();

    printActive("After starting VertX");
    for (int i = 0; i < 1000; i++) {
        vertx.deployVerticle(new MyVerticle());
        printActive("Regular verticle deployed");
    }

    printActive("Before deploying worker verticles");
    for (int i = 0; i < 1000; i++) {
        vertx.deployVerticle(new MyVerticle(), new DeploymentOptions().setWorker(true));
        printActive("Worker verticle deployed");
    }

    printActive("After everything deployed");

    System.out.println(new TreeMap(threadCounts));

    AtomicInteger count = new AtomicInteger(0);
    threadCounts.forEach((key, value) -> {
        count.addAndGet(value.get());
    });

    System.out.println(count.get());
}

private static void printActive(String message) {
    System.out.println(message);
    System.out.println(Thread.activeCount());
}

static class MyVerticle extends AbstractVerticle {

    @Override
    public void start() {
        threadCounts.putIfAbsent(Thread.currentThread().getName(), new AtomicInteger(0));
        threadCounts.get(Thread.currentThread().getName()).incrementAndGet();
    }

    @Override
    public void stop() throws Exception {
        System.out.println("Stopped");
    }
}
}

公共类事件循环示例{
静态映射线程计数=新的ConcurrentHashMap（）；
公共静态void main（字符串[]args）{
printActive（“启动VertX前”）；
Vertx Vertx=Vertx.Vertx（）；
printActive（“启动VertX后”）；
对于（int i=0；i<1000；i++）{
vertx.deployVerticle（新的MyVerticle（））；
printActive（“常规垂直部署”）；
}
printActive（“在部署工作竖梃之前”）；
对于（int i=0；i<1000；i++）{
deployVerticle（new MyVerticle（），new DeploymentOptions（）.setWorker（true））；
printActive（“工人垂直部署”）；
}
printActive（“部署一切后”）；
System.out.println（新树映射（线程计数））；
AtomicInteger计数=新的AtomicInteger（0）；
threadCounts.forEach（（键，值）->{
count.addAndGet（value.get（））；
});
System.out.println（count.get（））；
}
私有静态void printActive（字符串消息）{
System.out.println（消息）；
System.out.println（Thread.activeCount（））；
}
静态类MyVerticle扩展了AbstractVerticle{
@凌驾
公开作废开始（）{
putIfAbsent（Thread.currentThread（）.getName（），新的AtomicInteger（0））；
threadCounts.get（Thread.currentThread（）.getName（））.incrementAndGet（）；
}
@凌驾
public void stop（）引发异常{
系统输出打印项次（“停止”）；
}
}
}

注: 在VertX启动之前，有两个线程处于活动状态
即使您没有部署verticles，VertX的启动也会增加2个线程
EventLoop线程数由核心数定义。由于我有8个内核，VertX最多创建8个线程。
工作线程池默认为20个线程。
所以，除非你创造更多的工人