java 异步执行代码(先返回结果，后执行代码-Toy模板网

这篇具有很好参考价值的文章主要介绍了java 异步执行代码(先返回结果，后执行代码。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

业务场景：

在用户那，角色那变更后，要更新数据，因为更新要比较长时间，需要先返回结果（2:已接收待执行）。更新结束后，再返回值结果。

（执行结果. 0:执行失败； 1:执行成功； 2:已接收待执行）

处理1：简单异步

使用 ExecutorService 异步

    public void onCallback(JSONObject param) {
        ExecutorService executor = Executors.newCachedThreadPool();
        executor.execute(() -> {
            try {
                Thread.sleep(1000 * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 这边执行具体的方法
            this.syncDealResult(param);

        });
        executor.shutdown();
    }

    public JSONObject dealResult(JSONObject params) {
        // 先返回结果，然后异步执行
        this.onCallback(params);
        JSONObject result = new JSONObject();
        result.put("excRs", "2");
        return result;
    }
 

    public void syncDealResult(JSONObject params) {
        logger.info("deal abRole param {}", JSON.toJSONString(params));
        String logId = MapUtils.getString(params, "logId");
        String excRs = "1";
        try {
            // 具体操作
        } catch (Exception e) {
            e.printStackTrace();
            excRs = "-1";
        }
        logger.info("update abRole finish callRecordId {}, excRs {}", logId, excRs);
        // 处理完后推送结果
        JSONObject param = new JSONObject();
        param.put("logId", logId);
        param.put("excRs", excRs);
        // 推送结果
    }

加 Thread.sleep(1000 * 10); 就明显看得出差别了。

如果是有多种异步执行，比如：A执行完后，B要做通知；C要入库；D要做统计，这时候要怎么处理呢？

处理2：多个异步执行

IRoleCallback

import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;

/**
 * AB角色异步调用接口
 *
 */
public interface IRoleCallback {

    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @param param 结果
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    Object call(JSONObject param) throws Exception;

    /**
     * unique name of callback
     *
     * @return callback name
     */
    default String name() {
        return StringUtils.uncapitalize(getClass().getSimpleName());
    }

    /**
     * prior to callback 用于排序
     *
     * @return order
     */
    default double order() {
        return 1.0d;
    }

}

RoleCallbackRegister

import java.util.*;

public class RoleCallbackRegister {
    private static final Map<String, IRoleCallback> CALLBACKS = new HashMap<>();

    public static boolean register(IRoleCallback callback) {
        if (CALLBACKS.containsKey(callback.name())) {
            return false;
        }
        CALLBACKS.put(callback.name(), callback);
        return true;
    }

    public static List<IRoleCallback> getCallbacks() {
        List<IRoleCallback> roleCallbacks = new ArrayList<>(CALLBACKS.values());
        roleCallbacks.sort(Comparator.comparingDouble(IRoleCallback::order));
        return roleCallbacks;
    }
}

SpringUtils

@Component
public class SpringUtils implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringUtils.applicationContext = applicationContext;
    }

    public static Object getBean(String name) {
        return applicationContext.getBean(name);
    }

    public static <T> T getBean(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }
}

AbstractRoleCallbackImpl

import com.web.work.common.support.SpringUtils;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;

public abstract class AbstractRoleCallbackImpl implements IRoleCallback, InitializingBean {
    protected final Logger logger = LoggerFactory.getLogger(getClass());

    @Override
    public Object call(JSONObject param) throws Exception {
        return doCall(param);
    }

    protected abstract Object doCall(JSONObject param) throws Exception;

    @Override
    public String name() {
        return StringUtils.uncapitalize(getClass().getSimpleName());
    }

    @Override
    public void afterPropertiesSet() {
        boolean register = RoleCallbackRegister.register(SpringUtils.getBean(this.getClass()));
        if (!register) {
            logger.error("register role callback name:{} failed.", name());
        } else {
            logger.info("register role callback name:{} succeed.", name());
        }
    }
}

RoleCallBackService

@Service
public class RoleCallBackService implements InitializingBean, DisposableBean {

    private final static Logger logger = LoggerFactory.getLogger(RoleCallBackService.class);

    private ThreadPoolExecutor pool;

    public void onCallback(JSONObject param) {
        pool.execute(() -> {
            RoleCallbackRegister.getCallbacks().forEach(x -> {
                try {
                    logger.info("call {}", x.name());
                    x.call(param);
                } catch (Exception e) {
                    logger.error("回调{}接口失败：", x.name(), e);
                }
            });
        });
    }

    @Override
    public void afterPropertiesSet() {
        int size = Runtime.getRuntime().availableProcessors() + 1;
        pool = new ThreadPoolExecutor(size, size * 2, 300L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());
    }

    @Override
    public void destroy() throws Exception {
        pool.shutdown();
    }
}

RoleUpdateService

@Service
public class RoleUpdateService extends AbstractRoleCallbackImpl {

    private final static Logger logger = LoggerFactory.getLogger(RoleUpdateService.class);

    @Override
    protected Object doCall(JSONObject params) throws Exception {
        Thread.sleep(1000 * 10);
        logger.info("deal abRole param {}", JSON.toJSONString(params));
        String logId = MapUtils.getString(params, "logId");
        String excRs = "1";
        try {
            // 执行更新操作
        } catch (Exception e) {
            e.printStackTrace();
            excRs = "-1";
        }
        logger.info("update abRole finish callRecordId {}, excRs {}", logId, excRs);
        // 处理完后推送结果
        JSONObject param = new JSONObject();
        param.put("logId", logId);
        param.put("excRs", excRs);
        logger.info("update role record {}", JSON.toJSONString(param));
        // 推送结果
        return "";
    }
}

先返回结果后执行

    @Resource
    private RoleCallBackService roleCallBackService;

    public JSONObject dealResult(JSONObject params) {
        // 先返回结果，然后异步执行
        try {
            roleCallBackService.onCallback(params);
        } catch (Exception e) {
            e.printStackTrace();
        }
        JSONObject result = new JSONObject();
        result.put("excRs", "2");
        return result;
    }