REST uses multiple threads to improve server performance

REST Asynchronous Processing Service

 

1, the use of asynchronous processing Rest Runnable service

Release the main thread, the thread processing is enabled deputy, Vice return requests directly after completion of threading

The main code

import java.util.concurrent.Callable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * 
 * @author hzc
 *
 */
@RestController
public class AsyncController {

    private Logger logger = LoggerFactory.getLogger(AsyncController.class);

    @RequestMapping("/order")
    public Callable<String> order() throws{InterruptedException 
        logger.info ( "main thread start" ); 

        a Callable <String> Result = new new a Callable <String> () { 

            @Override 
            public String Call () throws Exception { 
                logger.info ( "sub thread starts" ); 
                the Thread. SLEEP ( 1000 ); 
                logger.info ( "sub-thread end" );
                 return "Success" ; 
            } 
            
        }; 
        logger.info ( "main thread return" );
         return Result;

    }
}

2, the use of asynchronous processing Rest DeferredResult Service

Releasing the main thread, the thread 1 is enabled sub pretreatment, post-processing sub-thread 2, after processing the sub-return request thread 2

Business scenario simulation

 

 

 Deputy main thread calls Thread 1 for business processing tasks put in the message queue, deputy thread 2 monitor message queues, and processing tasks queue, the queue using DeferredResult get the results returned, returned to the front

Controller class

package com.maple.security.web.async;

import org.apache.commons.lang.RandomStringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.DeferredResult;

/**
 * 
 * @author hzc
 *
 */
@RestController
public class AsyncController {

    private Logger logger = LoggerFactory.getLogger(AsyncController.class);

    @Autowired
    private MockQueue mockQueue;
    
    @Autowired
    private DeferredResultHolder deferredResultHolder;

    @RequestMapping("/order")
    public DeferredResult<String> order() throws InterruptedException {
        logger.info("主线程开始");

        String orderNumber = RandomStringUtils.randomNumeric(8);
        mockQueue.setPlaceOrder(orderNumber);
        
        DeferredResult<String> result = new DeferredResult<>();
        deferredResultHolder.getMap () PUT (the orderNumber, Result);. 
        logger.info ( "main thread return" );
         return Result; 

    } 
}

Simulation-based message queue

package com.maple.security.web.async;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * 
 * @author hzc
 *
 */
@Component
public class MockQueue {
    
    private Logger logger = LoggerFactory.getLogger(MockQueue.class);


    // 生成下单
    private String placeOrder;

    // 完成下单
    private String completeOrder;

    public String getPlaceOrder() {
        return placeOrder;
    }

     completeOrder;public  void setPlaceOrder (String the placeOrder) {
         new new the Thread (() -> { 
            logger.info ( "Order to request" );
             the try { 
                the Thread.sleep ( 1000 ); 
            } the catch (InterruptedException E) { 
                e.printStackTrace () ; 
            } 
            the this .completeOrder = the placeOrder; 
            logger.info ( "single request is processed," + the placeOrder); 
        }) Start ();. 

    } 

    public String getCompleteOrder () {
         return 
    } 

    public void setCompleteOrder(String completeOrder) {
        this.completeOrder = completeOrder;
    }
}

And processing the message queue listener class

package com.maple.security.web.async;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

@Component
public class QueueListener implements ApplicationListener<ContextRefreshedEvent> {

    private Logger logger = LoggerFactory.getLogger(QueueListener.class);

    @Autowired
    private MockQueue mockQueue;

    @Autowired
    private DeferredResultHolder deferredResultHolder;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {

        new Thread(() -> {
            while (true) {
                if (StringUtils.isNotBlank(mockQueue.getCompleteOrder())) {
                    String orderNumber = mockQueue.getCompleteOrder();
                    logger.info("返回订单处理结果：" + orderNumber);
                    deferredResultHolder.getMap().get(orderNumber).setResult("place order success");

                    mockQueue.setCompleteOrder(null);

                } else {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

    }
}

Asynchronous processing result class

/**
 * 
 */
package com.maple.security.web.async;

import java.util.HashMap;
import java.util.Map;

import org.springframework.stereotype.Component;
import org.springframework.web.context.request.async.DeferredResult;

/**
 * @author hzc
 *
 */
@Component
public class DeferredResultHolder {

    private Map<String, DeferredResult<String>> map = new HashMap<String, DeferredResult<String>>();

    public Map<String, DeferredResult<String>> getMap() {
        return map;
    }

    public void setMap(Map<String, DeferredResult<String>> map) {
        this.map = map;
    }

}

 

3, asynchronous processing configuration