Synchronized out

Getting results form queue from thread processing request (blockingMap variable should be returned by Spring Context as a singleton).

package com.example.configuration;

import com.jlupin.impl.client.delegator.balance.JLupinQueueLoadBalancerDelegatorImpl;
import com.jlupin.impl.client.util.JLupinClientUtil;
import com.jlupin.impl.client.util.queue.JLupinClientQueueUtil;
import com.jlupin.interfaces.client.delegator.JLupinDelegator;
import com.jlupin.interfaces.common.enums.PortType;
import com.jlupin.interfaces.microservice.partofjlupin.asynchronous.service.queue.JLupinQueueManagerService;
import com.jlupin.servlet.monitor.annotation.EnableJLupinSpringBootServletMonitor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Configuration
@EnableJLupinSpringBootServletMonitor
@ComponentScan("com.example")
public class ExampleSpringConfiguration {
    @Bean
    public JLupinDelegator getQueueJLupinDelegator() {
        final JLupinDelegator jLupinDelegator = JLupinClientUtil.generateInnerMicroserviceLoadBalancerDelegator(PortType.QUEUE);
        ((JLupinQueueLoadBalancerDelegatorImpl) jLupinDelegator).setGetStatusAnalyseAndChooseHighestFromAllEnvironment(true);
        return jLupinDelegator;
    }

    @Bean
    public JLupinQueueManagerService getJLupinQueueManagerService() {
        return JLupinClientUtil.generateRemote(getQueueJLupinDelegator(), "queueMicroservice", "jLupinQueueManagerService", JLupinQueueManagerService.class);
    }

    @Bean(name = "sampleQueueClientUtil")
    public JLupinClientQueueUtil getSampleQueueClientUtil() {
        return new JLupinClientQueueUtil("SAMPLE", getJLupinQueueManagerService());
    }

    @Bean(name = "blockingMap")
    public JLupinBlockingMap getJLupinBlockingMap() {
        return new JLupinBlockingMap();
    }
}

Invoke and wait for result in the same thread

@Autowired
private JLupinBlockingMap blockingMap;

@Autowired
@Qualifier("sampleQueueClientUtil")
private JLupinClientQueueUtil sampleQueueClientUtil;

public void waitForResultsInTheSameThread() throws Throwable {

    String taskId = jLupinClientQueueUtil.putTaskInput("sampleNativeMicroservice", "digestService", "getMD5Digest", new Object[]{ "1000", "1000" }); 

    blockingMap.ensureBlockingContainer(taskId); 

    jLupinClientQueueUtil.registerFunctionOnTaskResult(taskId, new JLupinQueueReactiveFunction() { 
        @Override 
        public void onSuccess(String taskId, Object result) { 
            blockingMap.put(taskId, result); 
        } 

        @Override 
        public void onError(String taskId, Throwable th) { 
            throw new IllegalStateException("am error occurred for taskId:" + taskId + " caused by:", th); 
        } 
    }); 

    Object result = blockingMap.get(taskId); 
    /** 
     * also available result = blockingMap.get(taskId, 10000, TimeUnit.MILLISECONDS); 
     */ 
    System.out.println("result = " + result + ", blocking map size:" + blockingMap. 
}