hilo principal no está esperando para suscriptores para terminar su tarea en suscriptor reactiva

Manshavi Kumar:

Tengo un servicio en la primavera de la que necesita para obtener los datos utilizando métodos de diez diferentes.

Me gustaría tener estos métodos se ejecutan paralelamente a hacer algunas operaciones de base de datos y volver a la rosca de los padres. Pero el hilo padre debe esperar hasta que todas las respuestas vienen a continuación, devolver una respuesta.

En mi enfoque actual, estoy usando mono reactiva para ejecutar todos los métodos de forma asíncrona pero el hilo principal no está esperando a que los métodos de suscriptores a fin.

A continuación son mis dos métodos que he suscrito

private Mono<BaseResponse> getProfileDetails(long profileId){
        return new Mono<BaseResponse>() {

            @Override
            public void subscribe(Subscriber<? super BaseResponse> s) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // DB Operation
                System.out.println("Inside getProfileDetails");
                s.onNext(new BaseResponse());
            }
        };
    }

private Mono<Address> getAddressDetails(long profileId){
        return new Mono<Address>() {

            @Override
            public void subscribe(Subscriber<? super Address> s) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // DB Operation
                System.out.println("Inside getAddressDetails");
                s.onNext(new Address());
            }
        };
    }

Y a continuación es mi método principal

public BaseResponse getDetails(long profileId){
        ExecutorService executors = Executors.newFixedThreadPool(2);

        Mono<BaseResponse> profileDetail = this.getProfileDetails(profileId).subscribeOn(Schedulers.fromExecutor(executors));
        Mono<BaseResponse> addressDetail = this.getAddressDetails(profileId).subscribeOn(Schedulers.fromExecutor(executors));

        List<BaseResponse> list = new ArrayList<>();

        profileDetail.mergeWith(addressDetail)
        .subscribe(consumer -> {
                list.add(consumer);
        });

        System.out.println("list: "+new Gson().toJson(list));
        executors.shutdown();

        return response;
    }

A continuación es mi salida:

list: []
Inside getProfileDetails
Inside getAddressDetails

Mi salida muestra que el hilo principal no está esperando que el abonado pueda terminar su tarea, así que ¿cómo puedo manejar esta situación?

Michael Berry:

Estoy asumiendo que su getProfileDetails()y getAddressDetails()métodos son marcadores de posición, ya que no tienen mucho sentido como está escrito.

Una vez dicho esto, si esto es toda su aplicación aquí, y realmente sólo quieren bloquear antes de terminar, es posible que también acaba de cambiar su actual subscribe()llamado a una doOnNext(), entonces simplemente blockLast():

profileDetail.mergeWith(addressDetail)
.doOnNext(consumer -> {
        list.add(consumer);
})
.blockLast();

El bloqueo en las roscas reactivos es por lo general poco aconsejable en aplicaciones de reactivos por una buena razón, pero en este caso que, literalmente, sólo quieren bloquear antes de salir de plano - así que no puedo ver mucho desventaja aquí.