Vert.x并发编程方式

Vert.x最爽的是标准Verticle中都是单线程，完全不用考虑线程安全问题

• 顺序执行

import io.vertx.core.*;

public class AsyncExample extends AbstractVerticle {
    public static void main(String[] args) {
        Vertx.vertx().deployVerticle(new AsyncExample());
    }

    @Override
    public void start() {
        // 方式1
        Future<String> future1 = fun1();
        future1.compose(this::fun2)
                .onSuccess(result -> {
                    System.out.println("1-"+result);
                })
                .onFailure(e -> {
                    System.out.println(e.getMessage());
                });
        // 方式2
        Future<String> future2 = fun1();
        future2.compose(this::fun2)
		        .onComplete(ar -> {
		            if (ar.succeeded()) {
		                System.out.println("2-"+ar.result());
		            } else {
		                System.out.println(ar.cause().getMessage());
		            }
		        });
    }

    private Future<String> fun1() {
        // 方式1
        return Future.future(promise -> {
            vertx.setTimer(100, l -> {
                promise.complete("world");
            });
        });
    }

    private Future<String> fun2(String name) {
        // 方式2
        Promise<String> promise = Promise.promise();
        vertx.setTimer(200, l -> {
            promise.complete("hello " + name);
        });
        return promise.future();
    }
}

• 并发执行

import io.vertx.core.AbstractVerticle;
import io.vertx.core.CompositeFuture;
import io.vertx.core.Future;
import io.vertx.core.Vertx;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class ParallelExample extends AbstractVerticle {
    public static void main(String[] args) {
        Vertx.vertx().deployVerticle(new ParallelExample());
    }

    @Override
    public void start() {
        List<Future> futures = IntStream.range(0, 100)
                .mapToObj(this::block)
                .collect(Collectors.toList());

        // all onSuccess所有的都成功，onFailure第一个失败
        // any onSuccess第一个成功，onFailure所有都失败
        // join onSuccess所有的都成功，onFailure所有都完成并且有至少一个失败
        CompositeFuture.all(futures)
                .onSuccess(cf -> cf.list().forEach(System.out::println))
                .onFailure(e -> System.out.println(e.getMessage()));
    }

    private Future<String> block(int i) {
        return Future.future(p -> {
            vertx.setTimer(100, l -> {
                p.complete(i + "-done");
            });
        });
    }
}