定时任务下发通知并更新数据库记录

使用的技术栈：
spring @Component注解
@Autowired资源注入
newFixedThreadPool固定大小的线程池
ReentrantLock同步锁
CountDownLatch倒计时器，是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
HTTP表单请求

package com.zcy.job;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.zcy.dao.NotifyMapper;
import com.zcy.model.Notify;
import com.zcy.utils.HttpClientHandler;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author zcy
 * 定时通知任务
 */
@Component
public class NotifyJob/* implements SimpleJob */{

    private static final Logger logger = LoggerFactory.getLoggerNotifyJob.class);

    @Autowired
    private NotifyMapper NotifyMapper;
    private ExecutorService pool = Executors.newFixedThreadPool(10);
    private ReentrantLock lock = new ReentrantLock(true);
    /*@Override*/
    public void execute() {
        try {
            logger.info("job begin");
            //获取同步锁，5秒内获取否则放弃执行任务
            boolean flag = lock.tryLock(5, TimeUnit.SECONDS);
            if (!flag) {
                logger.info("Job not get the lock");
                return;
            }
            //获取需要通知的数据库数据
            List<Notify> tl = NotifyMapper.getNotifys();
            if (CollectionUtils.isEmpty(tl)) {
                logger.info("NotifyJob query no data");
                return;
            }
            //加统计锁等待所有线程执行完毕释放同步锁
            CountDownLatch latch = new CountDownLatch(tl.size());
            for (Notify t : tl) {
                pool.execute(() -> {
                    try {
                        logger.info("NotifyJob begin handler uuid:{}",t.getLogId());
                        Map<String, String> param = JSON.parseObject(t.getNotifyStr(), Map.class);
                        String resultStr = HttpClientHandler.onRequestMap(param, t.getNotifyUrl(), "application/x-www-form-urlencoded");
                        logger.info("NotifyJob resultStr:{}", resultStr);
                        if (StringUtils.isNotEmpty(resultStr)) {
                            JSONObject result = JSON.parseObject(resultStr);
                            String code = result.getString("res_code");
                            if ("success".equals(code)) {
                                t.setResCode("S");
                                t.setResMsg(result.getString("res_msg"));
                            } else {
                                t.setResCode("F");
                                t.setResMsg(result.getString("res_msg"));
                            }
                        } else {
                            t.setResCode("F");
                            t.setResMsg(null);
                        }
                        logger.info("NotifyJob end handler uuid:{}",t.getLogId());
                    } catch (Exception e) {
                        logger.error("NotifyJob http error:", e);
                        t.setResMsg("system error");
                        t.setResCode("F");
                    }finally {
                        latch.countDown();
                    }
                    NotifyMapper.update(t);
                });
            }
            latch.await(200,TimeUnit.SECONDS);//最大等待所有线程完成的时间
        } catch (Exception e) {
            logger.error("NotifyJob handler error,  ",e);
        }finally {
            if (lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
        logger.info("NotifyJob notify end");

    }
}