Vertx executeBlocking使用事件循环而不是工作线程

Question

我来自一个请求=一个线程的概念，现在我想使用Vertx来理解事件循环的概念。根据文档，如果我们使用阻塞操作，我们应该将其传递给执行阻塞方法。

Verticles use the Vert.x worker pool for executing blocking actions, i.e executeBlocking or worker verticle.

我有一些问题与这一段从http://vertx.io/docs/vertx-core/groovy/

这是我的代码：

public class JdbcVertx extends AbstractVerticle{
    public static void main(String[] args) {
        Vertx v = Vertx.vertx();
        v.deployVerticle(new JdbcVertx(),new DeploymentOptions().setWorkerPoolSize(10));


    }
    @Override
    public void start() throws Exception {
        JDBCClient client = JDBCClient.createNonShared(this.vertx, new JsonObject()
                                .put("url", "jdbc:postgresql://localhost:5432/test")
                                .put("user", "postgres")
                                .put("password", "pw")
                                .put("driver_class", "org.postgresql.Driver")
                                .put("max_pool_size", 30));

        this.vertx.createHttpServer()
                .requestHandler(r -> {
                    int i = (int) (Math.random() * 100);
                    System.out.println("Req id: " + i+ " "+Thread.currentThread().getName());
                    client.getConnection(handler -> {
                        if (handler.failed()) {
                            throw new RuntimeException(handler.cause());
                        } else {
                            final SQLConnection connection = handler.result();
                            this.vertx.executeBlocking(blockingCodeHandler->{
                            connection.execute(execute(), hndlr -> {
                                connection.close(closehndlr -> {
                                    if (closehndlr.failed()) {
                                        throw new RuntimeException(closehndlr.cause());
                                    } else {
                                        System.out.println("CON end: "+i+" "+Thread.currentThread().getName());
                                        r.response().putHeader("content-type", "text/html").end("Response: " + i);
                                    }
                                });
                            });
                            },false,as->{});
                        }
                    });
                }).listen(8080);
    }

    private String execute(){     
            return "insert into rubbish (name) values ('test')";

    }

我向 http 服务器发送 100 个请求，这是输出：

Req id: 45 vert.x-eventloop-thread-0
Req id: 22 vert.x-eventloop-thread-0
Req id: 96 vert.x-eventloop-thread-0
Req id: 85 vert.x-eventloop-thread-0
Req id: 33 vert.x-eventloop-thread-0
CON end: 22 vert.x-eventloop-thread-0
CON end: 33 vert.x-eventloop-thread-0
CON end: 45 vert.x-eventloop-thread-0
CON end: 85 vert.x-eventloop-thread-0

1） 事件循环如何在请求之间切换（从输出中，它首先得到一些请求，然后给出响应）？

2)我使用了< code>executeBlocking方法，但是您可以看到上面的代码只使用了名为< code > vert . x-event loop-thread-0 的事件循环线程

3）根据第一个问题vertx事件循环在请求之间切换，但如果我更改方法执行为：

 private String execute(){ 
        Thread.sleep(3000);
            return "insert into rubbish (name) values ('test')";      
    }

它将停止事件循环，直到超时没有结束

提前谢谢你

Answer 1

1）您可以这样看待EventLoop：每次提供处理程序时，它都是另一个放在排序队列中的函数。

当您的第一个请求进来时，它可能看起来像这样的requestHandler（R1）requestHandler（R2）

然后EventLoop将弹出队列中的第一个元素，并将其结果放回队列：请求处理程序（R2）getConntions（R1）

然后第三个请求可能会进来，而我们弹出requestHandler （R2）：getConnection （ R1） requestHandler （R3） getConnection （R2）

并且重复，因此循环

2)实际上，您在阻塞处理程序中不做任何事情。在< code > if(closehndlr . failed()){ 之前添加一些大循环，您会看到警告。

现在发生的是，你在做< code >异步-

您可以使用以下代码看到这一点：

vertx.setPeriodic(1000, h -> {
        System.out.println("Periodic on " + Thread.currentThread().getName());
       vertx.executeBlocking(f -> {
           System.out.println("Future on " + Thread.currentThread().getName());
           f.complete();
       }, r -> {
           System.out.println("Result on " + Thread.currentThread().getName());
       });
    });

版画：

Periodic on vert.x-eventloop-thread-0
Future on vert.x-worker-thread-3
Result on vert.x-eventloop-thread-0
Periodic on vert.x-eventloop-thread-0
Future on vert.x-worker-thread-4
Result on vert.x-eventloop-thread-0

3） 不要使用 Thread.sleep（3000） :)通过这样做，您只需要求 EventLoop 停止 3 秒。您还应该看到有关此的警告。