伪代码复制代码假币问题Coin
输入：硬币所在数组的下标范围low和high，硬币的个数n
输出：假币在硬币集合中的序号
1. 如果n等于1，则该硬币即为假币，输出对应的序号，算法结束；
2. 计算3组的硬币个数num1、num2和num3；
3. add1=第一组硬币的重量和；add2=第二组硬币的重量和；
4. 根据情况执行下述三种操作之一：
    4.1 如果add1大于add2，则在第一组硬币中查找；
    4.2 如果add1大于add2，则在第二组硬币中查找；
    4.3 如果add1等于add2，则在第三组硬币中查找。

scss复制代码输入：nums = [1,4,3,2]
输出：4
解释：所有可能的分法（忽略元素顺序）为：
1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
所以最大总和为 4

scss复制代码输入：nums = [6,2,6,5,1,2]
输出：9
解释：最优的分法为 (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9

Kotlin复制代码class Solution {
    fun arrayPairSum(nums: IntArray): Int {
        nums.sort()
        val len = nums.size
        var maxNum = 0
        for (index in 0 until len step 2){
             maxNum += nums[index]
        }   
        return maxNum
    }
}

vbnet复制代码INSERT INTO sink_table
SELECT
    show_log.log_id as log_id,
    show_log.timestamp as timestamp,
    show_log.show_params as show_params,
    click_log.click_params as click_params
FROM show_log
LEFT JOIN click_log ON show_log.log_id = click_log.log_id;

vbnet复制代码INSERT INTO sink_table
SELECT
    show_log.log_id as log_id,
    show_log.timestamp as timestamp,
    show_log.show_params as show_params,
    click_log.click_params as click_params
FROM show_log
LEFT JOIN click_log ON show_log.log_id = click_log.log_id;

yaml复制代码+[1 | 2021-11-01 00:01:03 | show_params | null]
-[1 | 2021-11-01 00:01:03 | show_params | null]
+[1 | 2021-11-01 00:01:03 | show_params | click_params]
+[2 | 2021-11-01 00:03:00 | show_params | click_params]
+[3 | 2021-11-01 00:05:00 | show_params | null]

java复制代码i = 0
n = 15
an = 1
while i < n:
an1Pow = 2 - math.sqrt(4-math. pow( an,2))
an1 = math.sqrt(an1Pow)
an = an1
i += 1
print("由正%d边形求出的PI为%.5Of”% (6*math.pow(2，n)，(3*math.pow(2，n)*an)))

java复制代码s = 0
result = 0
for i in range(0，100):
    s += (-1)**i /(2*i+1)
    result = s*4
print(’%.2f’ % result)

java复制代码public class PI {

    public static void main(string[ ] args) {
        int test_sum = 1000000;//投的点数
        int hit_sum = o;//投中的个数
        double x, y;// x和y坐标点
        for (int i = o; i < test_sum; i++) {
            //随机得到一个坐标
             x = Math.random();
             y = Math.random( );
             
    if (x* x +y * y <= 1)//判断掷入的这个点在不在在圆内
        hit_sum++;
}
//统计得到rt的值
double pi = (double) hit_sum / test_sum * 4;
System.out.println(“π的结果为:" + pi);
}
}

java复制代码@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

java复制代码 getResponse(dto, response, new Consumer<B>() {
    @Override
    public void accept(B bb) {
      mapper.insert(bb);
    }
});

java复制代码@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }


    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

   
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

java复制代码@Data
@AllArgsConstructor
public class Teacher {
    private String name;
    private int age;
}

public class TeacherTest {
    public static void main(String[] args) {
       List<Teacher> list = Arrays.asList(
            new Teacher("张三",25),
            new Teacher("李四",28),
            new Teacher("王五",18));
      List<String> collect = list.stream().map(item -> item.getName()).collect(Collectors.toList());
      System.out.println(collect);
    }
}

xml复制代码[张三, 李四, 王五]

less复制代码public interface InstantiationStrategy {
    Object instantiate(RootBeanDefinition var1, @Nullable String var2, BeanFactory var3) throws BeansException;

    Object instantiate(RootBeanDefinition var1, @Nullable String var2, BeanFactory var3, Constructor<?> var4, Object... var5) throws BeansException;

    Object instantiate(RootBeanDefinition var1, @Nullable String var2, BeanFactory var3, @Nullable Object var4, Method var5, Object... var6) throws BeansException;
}

less复制代码public class SimpleInstantiationStrategy implements InstantiationStrategy {
    private static final ThreadLocal<Method> currentlyInvokedFactoryMethod = new ThreadLocal();

    public SimpleInstantiationStrategy() {
    }

    @Nullable
    public static Method getCurrentlyInvokedFactoryMethod() {
        return (Method)currentlyInvokedFactoryMethod.get();
    }

    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
       //...
    }

    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner, Constructor<?> ctor, Object... args) {
      //...
    }

    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner, @Nullable Object factoryBean, Method factoryMethod, Object... args) {
      //...
}

typescript复制代码@Component
public class rulesFactory {
    private static final Map<Integer,RuleStrategy> map = new HashMap<>(20);

    @Resource
    public selectStrategy selectStrategy;

    //@PostConstruct 用来修饰一个非静态的void()方法.而且这个方法不能有抛出异常声明。在服务器加载Servlet的时候运行,并且只会被服务器调用一次
    @PostConstruct
    public void init(){
        map.put(1,selectStrategy);
    }

    public RuleStrategy creator(Integer type) {
        return map.get(type);
    }
}

csharp复制代码public interface RuleStrategy<T extends RulesProcessorBO> {
    
    void process(T t);
}

typescript复制代码@Component
public class RuleContext {

    @Resource
    private rulesFactory bizRuleFactory;

    public void process(RulesProcessorBO rulesProcessorBO) {

        bizRuleFactory.creator(rulesProcessorBO.getRuleCode()).process(rulesProcessorBO);

    }

}

less复制代码@Component
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
public class selectStrategy implements RuleStrategy<selectProcessorBo> {

    @Autowired
    private ManagerMapper managerMapper;

    @Override
    public void process(selectProcessorBo rulesProcessorBO) {
        Manager m = managerMapper.getById("1");
        System.out.println(m.toString());

    }
}

txt复制代码https://book.kongfz.com/Cxiaoshuo/v6w1/
https://book.kongfz.com/Cxiaoshuo/v6w2/
https://book.kongfz.com/Cxiaoshuo/v6w3/

python复制代码import requests
from lxml.html import etree
import random
import time


class SSS:
    def __init__(self):

        self.url_format = 'https://book.kongfz.com/C{}/v6w{}/'
        # 待抓取的分类，可以扩展
        self.types = ["wenxue", "xiaoshuo"]
        self.session = requests.Session()
        self.headers = self.get_headers()
        self.categorys =[]

    def get_categorys(self):

        with self.session.get(url='https://book.kongfz.com/Cfalv/',headers=self.headers) as res:
            if res:
                html = etree.HTML(res.text)
                items = html.cssselect('.tushu div.link-item a')
                # 匹配出URL中的type
                for item in items:
                    # print(item)
                    # print(item.get("href"))
                    href = item.get("href")
                    type = href[href.find('C')+1:-1]
                    self.categorys.append(type)

txt复制代码xiaoshuo
wenxue
yuyan
lishi
dili
yishu
……

python复制代码    def get_detail(self, type, page):
        with self.session.get(url=self.url_format.format(type, page), headers=self.headers, timeout=5) as res:
            if res.text:
                with open(f"./孔夫子/{type}_{page}.html", "w+", encoding="utf-8") as f:
                    f.write(res.text)
            else:
                # 如果无数据，重新请求
                print(f"页码{page}请求异常，重新请求")
                self.get_detail(page)

    def run(self):
        pagesize = 5
        for type in self.types:
            for page in range(1, pagesize):
                self.get_detail(type, page)
                time.sleep(2)
                print(f"分类：{type}，页码：{page}页面储存完毕！")

python复制代码# 数据提取类
class Analysis:
    def __init__(self):
        # 待抓取的分类，可以扩展
        self.types = ["wenxue", "xiaoshuo"]

    # 去除特殊字符
    def remove_character(self, origin_str):
        if origin_str is None:
            return
        origin_str = origin_str.replace('\n', '')
        origin_str = origin_str.replace(',', '，')
        return origin_str

    def format(self, text):
        html = etree.HTML(text)
        # 获取所有项目区域 div
        div_books = html.cssselect('div#listBox>div.item')
        for book in div_books:
            # 获取标题属性值
            title = book.cssselect('div.item-info>div.title')[0].get('title')
            # 作者默认给空值
            author = None
            author_div = book.cssselect('div.item-info>div.zl-isbn-info>span:nth-child(1)')
            if len(author_div)>0:
                author = author_div[0].text
            # 出版社相同操作
            publisher = None
            publisher_div = book.cssselect('div.item-info>div.zl-isbn-info>span:nth-child(2)')
            if len(publisher_div)>0:
                # 进行数据提取与截取
                publisher = publisher_div[0].text.split(' ')[1]
            print(publisher)

    def run(self):
        pagesize = 5
        for type in self.types:
            for page in range(1, pagesize):
                with open(f"./孔夫子/{type}_{page}.html", "r", encoding="utf-8") as f:
                    text = f.read()
                    # print(text)
                    self.format(text)

txt复制代码长篇小说:达哈士孔的狒狒(精装) [法]阿尔丰斯·都德  著；李劼人  译 四川文艺出版社
剑王朝.4 论剑 无罪 长江出版社
只有月亮听得见 康玲玲 四川文艺出版社
元尊1·潜龙在渊 天蚕土豆  著 长江出版社
畅销书女王:张爱玲的33堂写作课 端木向宇 天津人民出版社
区块链改变世界 严行方 中国纺织出版社
我们还会再见吗 苗勇刚、贾宇萍  译 中国出版集团,现代出版社
仲夏夜之恋I 小妮子  著 作家出版社
长篇霸都亚纳(精装) [法]赫勒·马郎  著；李劼人  译 四川文艺出版社

java复制代码private XxlJobScheduler xxlJobScheduler;

java复制代码private static XxlJobAdminConfig adminConfig = null;

public static XxlJobAdminConfig getAdminConfig() {
    return adminConfig;
}

java复制代码@Override
public void afterPropertiesSet() throws Exception {
    adminConfig = this;

    xxlJobScheduler = new XxlJobScheduler();
    xxlJobScheduler.init();
}

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

java复制代码public void init() throws Exception {
  // 0、初始化国际化消息，不是很重要忽略
  initI18n();

  // 1、初始化调度器的线程池
  JobTriggerPoolHelper.toStart();

  // 2、启动注册监视器线程
  JobRegistryHelper.getInstance().start();

  // 3、启动 失败 job 监视器线程，查询失败日志进行重试
  JobFailMonitorHelper.getInstance().start();

  // 4、启动 丢失 job 监视器线程，一些 job 发出调度指令后，一直没有响应，状态一直是“运行中”
  JobCompleteHelper.getInstance().start();

  // 5、启动日志统计和清理线程
  JobLogReportHelper.getInstance().start();

  // 6、启动调度线程，定时调度 job
  JobScheduleHelper.getInstance().start();

  logger.info(">>>>>>>>> init xxl-job admin success.");
}

java复制代码/**
 * 快速、慢速线程池，分别执行调度任务不一样的任务，实现隔离，避免相互阻塞
 */
private ThreadPoolExecutor fastTriggerPool = null;
private ThreadPoolExecutor slowTriggerPool = null;

public void start() {
    fastTriggerPool = new ThreadPoolExecutor(
        10,
        // 至少200
        XxlJobAdminConfig.getAdminConfig().getTriggerPoolFastMax(),60L,TimeUnit.SECONDS,new LinkedBlockingQueue<>(1000),      
        r -> new Thread(r, "xxl-job, admin JobTriggerPoolHelper-fastTriggerPool-" + r.hashCode()));

    slowTriggerPool = new ThreadPoolExecutor(
        10,
        // 至少100
        XxlJobAdminConfig.getAdminConfig().getTriggerPoolSlowMax(),60L,TimeUnit.SECONDS,new LinkedBlockingQueue<>(2000),
        r -> new Thread(r, "xxl-job, admin JobTriggerPoolHelper-slowTriggerPool-" + r.hashCode()));
}

java复制代码// 属性变量
private volatile ConcurrentMap<Integer, AtomicInteger> jobTimeoutCountMap = new ConcurrentHashMap<>();

// 选择线程池，如果在一分钟内调度超过10次，使用 slowTriggerPool
ThreadPoolExecutor triggerPool_ = fastTriggerPool;
AtomicInteger jobTimeoutCount = jobTimeoutCountMap.get(jobId);
if (jobTimeoutCount != null && jobTimeoutCount.get() > 10) {
  triggerPool_ = slowTriggerPool;
}

java复制代码// 属性变量，初始值等于 JobTriggerPoolHelper 对象构造时的分钟数
// 每次调用 XxlJobTrigger.trigger() 方法时，值等于上一次调用的分钟数
private volatile long minTim = System.currentTimeMillis() / 60000;

// 当前时间的分钟数，如果和前一次调用不在同一分钟内，就清空 jobTimeoutCountMap
long minTim_now = System.currentTimeMillis() / 60000;
if (minTim != minTim_now) {
    minTim = minTim_now;
    jobTimeoutCountMap.clear();
}

// 开始调用 XxlJobTrigger.trigger() 的时间
long start = System.currentTimeMillis();

// ... 调用 XxlJobTrigger.trigger() 方法
XxlJobTrigger.trigger(jobId, triggerType, failRetryCount, executorShardingParam, executorParam, addressList);

// 如果用时超过 500 毫秒，就增加一次它的慢调用次数
long cost = System.currentTimeMillis() - start;
if (cost > 500) {
    AtomicInteger timeoutCount = jobTimeoutCountMap.putIfAbsent(jobId, new AtomicInteger(1));
    if (timeoutCount != null) {
        timeoutCount.incrementAndGet();
    }
}

java复制代码// 注册或移除 executor 的线程池
private ThreadPoolExecutor registryOrRemoveThreadPool = null;

// 注册或移除线程池
registryOrRemoveThreadPool = new ThreadPoolExecutor(
    2,    10,    30L,    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(2000),
    r -> new Thread(r, "xxl-job, admin JobRegistryMonitorHelper-registryOrRemoveThreadPool-" + r.hashCode()),
    (r, executor) -> {
        r.run();
        logger.warn(">>>>>>>>>>> xxl-job, registry or remove too fast, match thread pool rejected handler(run now).");
    });

java复制代码public ReturnT<String> registry(RegistryParam registryParam) {
	// 校验参数
    if (!StringUtils.hasText(registryParam.getRegistryGroup())
        || !StringUtils.hasText(registryParam.getRegistryKey())
        || !StringUtils.hasText(registryParam.getRegistryValue())) {
        return new ReturnT<>(ReturnT.FAIL_CODE, "Illegal Argument.");
    }
	// 在线程池中创建线程
    registryOrRemoveThreadPool.execute(() -> {
        // update
        int ret = XxlJobAdminConfig.getAdminConfig().getXxlJobRegistryDao()
            .registryUpdate(registryParam.getRegistryGroup(), registryParam.getRegistryKey(),
                            registryParam.getRegistryValue(), new Date());
        // update 失败，insert
        if (ret < 1) {
            XxlJobAdminConfig.getAdminConfig().getXxlJobRegistryDao()
                .registrySave(registryParam.getRegistryGroup(), registryParam.getRegistryKey(),
                              registryParam.getRegistryValue(), new Date());
            // 刷新，空方法
            freshGroupRegistryInfo(registryParam);
        }
    });
    return ReturnT.SUCCESS;
}

java复制代码// 注册监视器线程
private Thread registryMonitorThread;

// 停止标志位
private volatile boolean toStop = false;


// 自动注册的 job group
List<XxlJobGroup> groupList = XxlJobAdminConfig.getAdminConfig().getXxlJobGroupDao().findByAddressType(0);

// 删除已经下线（90 秒内没有心跳）的注册 admin/executor
List<Integer> ids = XxlJobAdminConfig.getAdminConfig().getXxlJobRegistryDao().findDead(RegistryConfig.DEAD_TIMEOUT, new Date());
if (ids != null && ids.size() > 0) {
    XxlJobAdminConfig.getAdminConfig().getXxlJobRegistryDao().removeDead(ids);
}

// 刷线还在线（90秒内有心跳）的 admin/executor 的地址 map<appName,List<address>>
List<XxlJobRegistry> list = XxlJobAdminConfig.getAdminConfig().getXxlJobRegistryDao().findAll(RegistryConfig.DEAD_TIMEOUT, new Date());
HashMap<String, List<String>> appAddressMap = new HashMap<>(list.size());
// 略...


// 每 30 秒执行一次
TimeUnit.SECONDS.sleep(RegistryConfig.BEAT_TIMEOUT);

java复制代码/**
 * 监视器线程
 */
private Thread monitorThread;

java复制代码// UPDATE 语句给该条记录加互斥锁，如果能加上，说明没有其他线程在修改该记录，也说明该记录还没被修改过
// 设置新值 -1，表示该记录已经被加锁了
int lockRet = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao()
  .updateAlarmStatus(failLogId, 0, -1);
if (lockRet < 1) {
  continue;
}

// 解锁
xlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateAlarmStatus(failLogId,-1, newAlarmStatus);

java复制代码// 取出失败的日志和对应的 job
XxlJobLog log = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().load(failLogId);
XxlJobInfo info = XxlJobAdminConfig.getAdminConfig().getXxlJobInfoDao().loadById(log.getJobId());

// 1、重试失败的 job，更新日志的 trigger_msg 字段值
if (log.getExecutorFailRetryCount() > 0) {
    // 调度任务调度
    JobTriggerPoolHelper.trigger(log.getJobId(), TriggerTypeEnum.RETRY,
                                 (log.getExecutorFailRetryCount() - 1),
                                 log.getExecutorShardingParam(), log.getExecutorParam(), null);
    String retryMsg = "<br><br><span style=\"color:#F39C12;\" > >>>>>>>>>>>" + I18nUtil.getString("jobconf_trigger_type_retry") + "<<<<<<<<<<< </span><br>";
    log.setTriggerMsg(log.getTriggerMsg() + retryMsg);
    // 更新 log
    XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateTriggerInfo(log);
}

// 2、如果 job 不为空，说明存在失败的任务，发送告警消息
// 告警状态：0-默认、-1=锁定状态、1-无需告警、2-告警成功、3-告警失败
int newAlarmStatus = 0;
if (info != null) {
    boolean alarmResult = XxlJobAdminConfig.getAdminConfig().getJobAlarmer().alarm(info, log);
    newAlarmStatus = alarmResult ? 2 : 3;
} else {
    newAlarmStatus = 1;
}

// 3、更新 jobLog 的 alarm_status 值
XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateAlarmStatus(failLogId, -1, newAlarmStatus);

java复制代码/**
 * 接收回调请求的线程池
 */
private ThreadPoolExecutor callbackThreadPool = null;

// 初始化线程池
callbackThreadPool = new ThreadPoolExecutor(
  2, 20, 30L, TimeUnit.SECONDS,
  new LinkedBlockingQueue<>(3000),
  r -> new Thread(r, "xxl-job, admin JobLosedMonitorHelper-callbackThreadPool-" + r.hashCode()),
  (r, executor) -> {
    r.run();
    logger.warn(">>>>>>>>>>> xxl-job, callback too fast, match threadpool rejected handler(run now).");
  });

java复制代码// 在线程池中创建线程处理回调参数
public ReturnT<String> callback(List<HandleCallbackParam> callbackParamList) {

    callbackThreadPool.execute(new Runnable() {
        @Override
        public void run() {
            for (HandleCallbackParam handleCallbackParam : callbackParamList) {
                ReturnT<String> callbackResult = callback(handleCallbackParam);
                // ...
            }
        }
    });
    return ReturnT.SUCCESS;
}

private ReturnT<String> callback(HandleCallbackParam handleCallbackParam) {
    // valid log item
    XxlJobLog log = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().load(handleCallbackParam.getLogId());
    // 更新 log 数据，略...
    
    // 更新和完成 job
    XxlJobCompleter.updateHandleInfoAndFinish(log);

    return ReturnT.SUCCESS;
}

java复制代码/**
 * 监视 丢失job 的线程
 */
private Thread monitorThread;

// 任务结果丢失处理：调度记录停留在 "运行中" 状态超过10min，且对应执行器心跳注册失败不在线，则将本地调度主动标记为失败
Date losedTime = DateUtil.addMinutes(new Date(), -10);
List<Long> losedJobIds = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().findLostJobIds(losedTime);

if (losedJobIds != null && losedJobIds.size() > 0) {
    for (Long logId : losedJobIds) {

        XxlJobLog jobLog = new XxlJobLog();
        jobLog.setId(logId);

        jobLog.setHandleTime(new Date());
        // 设置 handler_code
        jobLog.setHandleCode(ReturnT.FAIL_CODE);
        jobLog.setHandleMsg(I18nUtil.getString("joblog_lost_fail"));
        // 更新执行信息和结束 job
        XxlJobCompleter.updateHandleInfoAndFinish(jobLog);
    }
}

java复制代码// 根据上次执行时间、配置的过期参数，来决定是否执行清理
// 上次清理时间与当前超过1天才清理
long lastCleanLogTime = 0;


if (XxlJobAdminConfig.getAdminConfig().getLogretentiondays() > 0
    && System.currentTimeMillis() - lastCleanLogTime > 24 * 60 * 60 * 1000) {
  // 清理的开始时间... 略

  // 开始清理日志
  List<Long> logIds = null;
  do {
    logIds = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().findClearLogIds(
      0, 0, clearBeforeTime, 0, 1000);
    if (logIds != null && logIds.size() > 0) {
      XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().clearLog(logIds);
    }
  } while (logIds != null && logIds.size() > 0);

  // 更新执行清理操作的时间
  lastCleanLogTime = System.currentTimeMillis();
}

java复制代码/**
 * 预读的毫秒数
 */
public static final long PRE_READ_MS = 5000;
/**
 * 预读和调度过期任务的线程
 */
private Thread scheduleThread;

java复制代码if (nowTime > jobInfo.getTriggerNextTime() + PRE_READ_MS) {
  logger.warn(">>>>>>>>>>> xxl-job, schedule misfire, jobId = " + jobInfo.getId());

  MisfireStrategyEnum misfireStrategyEnum = MisfireStrategyEnum.match(jobInfo.getMisfireStrategy(), MisfireStrategyEnum.DO_NOTHING);
  if (MisfireStrategyEnum.FIRE_ONCE_NOW == misfireStrategyEnum) {
    // 调度一次
    JobTriggerPoolHelper.trigger(jobInfo.getId(), TriggerTypeEnum.MISFIRE, -1, null, null, null);
    logger.debug(">>>>>>>>>>> xxl-job, schedule push trigger : jobId = " + jobInfo.getId());
  }
  // 更新下一次执行时间
  refreshNextValidTime(jobInfo, new Date());
}

java复制代码if (nowTime > jobInfo.getTriggerNextTime()) {
    // 1、 调度一次
    JobTriggerPoolHelper.trigger(jobInfo.getId(), TriggerTypeEnum.CRON, -1, null, null, null);
    logger.debug(">>>>>>>>>>> xxl-job, schedule push trigger : jobId = " + jobInfo.getId());
    // 2、 更新下一次调度时间
    refreshNextValidTime(jobInfo, new Date());

    // 3、 如果当前 job 处于 ”可以被调度“ 的状态，且下一次执行时间在 5000 毫秒内，就记录下 job Id，等待后面轮询
    if (jobInfo.getTriggerStatus() == 1 && nowTime + PRE_READ_MS > jobInfo.getTriggerNextTime()) {
        // 下次调度的时刻：秒
        int ringSecond = (int) ((jobInfo.getTriggerNextTime() / 1000) % 60);
        // 保存进 ringData 中
        pushTimeRing(ringSecond, jobInfo.getId());
        // 刷新下一次的调度时间
        refreshNextValidTime(jobInfo, new Date(jobInfo.getTriggerNextTime()));
    }
}

java复制代码int ringSecond = (int) ((jobInfo.getTriggerNextTime() / 1000) % 60);
pushTimeRing(ringSecond, jobInfo.getId());
refreshNextValidTime(jobInfo, new Date(jobInfo.getTriggerNextTime()));

java复制代码// 更新 job 数据
for (XxlJobInfo jobInfo : scheduleList) {
  XxlJobAdminConfig.getAdminConfig().getXxlJobInfoDao().scheduleUpdate(jobInfo);
}

java复制代码// 获取数据库链接，通过 SELECT FOR UPDATE 来尝试获取 X锁
// 在事务提交前一直持有该锁，其他实例的线程想获取该锁就会失败，并且会排队等待，直到第一个事务提交释放或锁超时
conn = XxlJobAdminConfig.getAdminConfig().getDataSource().getConnection();
connAutoCommit = conn.getAutoCommit();
conn.setAutoCommit(false);
preparedStatement = conn.prepareStatement("select * from xxl_job_lock where lock_name = 'schedule_lock' for update");
preparedStatement.execute();


// 提交事务，释放 X锁
if (conn != null) {
  try {
    conn.commit();
  } catch (SQLException e) {
    // ...
  }
  try {
    conn.setAutoCommit(connAutoCommit);
  } catch (SQLException e) {
    // ...
  }
  try {
    conn.close();
  } catch (SQLException e) {
    // ...
  }
}

java复制代码try {
  // 随机 sleep 4000~5000 毫秒，通过这种方式，降低多实例部署时对锁的竞争
  // 这里也看出来，最多部署 5000 台实例 ==..==
  TimeUnit.MILLISECONDS.sleep(5000 - System.currentTimeMillis() % 1000);
} catch (InterruptedException e) {
  if (!scheduleThreadToStop) {
    logger.error(e.getMessage(), e);
  }
}


// 耗时超过 1000 毫秒，就不 sleep
// 不超过 1000 ms，就 sleep 一个随机时长
long cost = System.currentTimeMillis() - start;
if (cost < 1000) {
  try {
    // 没有预读数据，就 sleep 时间长一点；有预读数据，就 sleep 时间短一些
    TimeUnit.MILLISECONDS.sleep((preReadSuc ? 1000 : PRE_READ_MS) - System.currentTimeMillis() % 1000);
  } catch (InterruptedException e) {
    if (!scheduleThreadToStop) {
      logger.error(e.getMessage(), e);
    }
  }
}

java复制代码/**
 * 调度线程2
 */
private Thread ringThread;
/**
 * 按时刻（秒）调度 job
 */
private volatile static Map<Integer, List<Integer>> ringData = new ConcurrentHashMap<>();

// 调度过程

List<Integer> ringItemData = new ArrayList<>();
// 每次取出 2 个时刻的 job 来调度
int nowSecond = Calendar.getInstance().get(Calendar.SECOND);
for (int i = 0; i < 2; i++) {
  List<Integer> tmpData = ringData.remove((nowSecond + 60 - i) % 60);
  if (tmpData != null) {
    ringItemData.addAll(tmpData);
  }
}
// 遍历 job Id，执行调度
if (ringItemData.size() > 0) {
  for (int jobId : ringItemData) {
    JobTriggerPoolHelper.trigger(jobId, TriggerTypeEnum.CRON, -1, null, null, null);
  }
  ringItemData.clear();
}

java复制代码try {
  TimeUnit.MILLISECONDS.sleep(1000 - System.currentTimeMillis() % 1000);
} catch (InterruptedException e) {
  if (!ringThreadToStop) {
    logger.error(e.getMessage(), e);
  }
}

java复制代码/**
 * 销毁，销毁过程与 init 顺序相反
 */
public void destroy() throws Exception {

  // 1、销毁 调度线程
  JobScheduleHelper.getInstance().toStop();

  // 2、销毁 日志统计和清理线程
  JobLogReportHelper.getInstance().toStop();

  // 3、销毁 丢失 job 监视器线程
  JobCompleteHelper.getInstance().toStop();

  // 4、销毁 失败 job 监视器线程
  JobFailMonitorHelper.getInstance().toStop();

  // admin registry stop
  JobRegistryHelper.getInstance().toStop();

  // admin trigger pool stop
  JobTriggerPoolHelper.toStop();
}

java复制代码scheduleThreadToStop = true;
// 给线程 1s 的时间去执行任务
try {
  TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
  logger.error(e.getMessage(), e);
}
// 如果线程不是终止状态，就让它执行完所有任务
if (scheduleThread.getState() != Thread.State.TERMINATED) {
  scheduleThread.interrupt();
  try {
    scheduleThread.join();
  } catch (InterruptedException e) {
    logger.error(e.getMessage(), e);
  }
}

java复制代码ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(address);
runResult = executorBiz.run(triggerParam);

java复制代码private static ConcurrentMap<String, ExecutorBiz> executorBizRepository = new ConcurrentHashMap<String, ExecutorBiz>();

public static ExecutorBiz getExecutorBiz(String address) throws Exception {
  // valid
  if (address == null || address.trim().length() == 0) {
    return null;
  }

  // load-cache
  address = address.trim();
  ExecutorBiz executorBiz = executorBizRepository.get(address);
  if (executorBiz != null) {
    return executorBiz;
  }

  // set-cache
  executorBiz = new ExecutorBizClient(address, XxlJobAdminConfig.getAdminConfig().getAccessToken());

  executorBizRepository.put(address, executorBiz);
  return executorBiz;
}

java复制代码private static void finishJob(XxlJobLog xxlJobLog) {
  // 1、job 执行成功，开始调度子任务handle success, to trigger child job
  StringBuilder triggerChildMsg = null;
  if (XxlJobContext.HANDLE_CODE_SUCCESS == xxlJobLog.getHandleCode()) {
    XxlJobInfo xxlJobInfo = XxlJobAdminConfig.getAdminConfig().getXxlJobInfoDao().loadById(xxlJobLog.getJobId());
    if (xxlJobInfo != null && xxlJobInfo.getChildJobId() != null && xxlJobInfo.getChildJobId().trim().length() > 0) {
	  // 2、遍历子任务ID
      String[] childJobIds = xxlJobInfo.getChildJobId().split(",");
      for (int i = 0; i < childJobIds.length; i++) {
        int childJobId = (childJobIds[i] != null && childJobIds[i].trim().length() > 0 && isNumeric(childJobIds[i])) ? Integer.parseInt(childJobIds[i]) : -1;
        if (childJobId > 0) {
          // 3、调度子任务
          JobTriggerPoolHelper.trigger(childJobId, TriggerTypeEnum.PARENT, -1, null, null, null);
          ReturnT<String> triggerChildResult = ReturnT.SUCCESS;
          // 4、添加日志信息....略 
      }
    }
  }
  // 5、保存子任务的调度消息到日志
  if (triggerChildMsg != null) {
    xxlJobLog.setHandleMsg(xxlJobLog.getHandleMsg() + triggerChildMsg);
  }
}