背景

專案中開發一個任務執行模組以下簡稱執行模組，由別的模組呼叫執行模組計算任務的結果，計算完成後需要把結算結果、計算狀態、計算耗時等資訊更新到Mysql庫裡，執行模組是來一個任務執行一次更新一次，後來發現這樣需要頻繁的與Mysql互動，且需要等待寫庫結果返回，效率堪憂拖慢其他模組。

優化

第一步：用執行緒池來更新，將更新程式碼提交到執行緒池中，由執行緒池排程入庫
缺點：沒有解決與資料庫頻繁互動的問題。
第二步：執行模組不管更新結果，只需將更新任務放入一個佇列中然後直接返回；用Spring的定時任務註解@Scheduled，指定一個方法，隔一段時間呼叫一次入庫方法；入庫的邏輯是，獲取隊列當前任務個數cnt，迴圈poll任務然後新增到一個List中，poll夠cnt個之後，通過批量更新方法將List更新到資料庫。
缺點：定時執行無法控制佇列大小，可能一次會取出很多條任務，也可能會把佇列撐得過大。
第三步：使用阻塞佇列放更新任務，用守護執行緒poll的佇列中的任務，當條數等於5000條(此值根據實際情況)，則批量更新一次，在poll時設定超時時間為30秒，當超過30秒還是沒有取到任務，則也批量把已經渠道的任務更新一次。

總結：沒有三板斧都不好意思寫程式碼！！！

佇列實現

@Service
public class JobExecutorDataServiceImpl {
    //定義一個容量為10000的阻塞佇列，BlockingQueue執行緒安全可以多個生產者同時put
    private BlockingQueue<Job> dataQueue = new LinkedBlockingQueue<>(10000);

    //put任務的方法，供生產者呼叫
    public void recordJob(Job job) {
        try {
            dataQueue.put(job);
        } catch
 
 (InterruptedException e) {
            LOGGER.info("批量更新Job入佇列異常");
            Thread.currentThread().interrupt();
        }
    }

    //初始化即呼叫
    @PostConstruct
    private void batchUpdate() {
        Thread thread = new Thread(() -> {
            LOGGER.info("啟動批量更新守護執行緒，啟動時間{}", new Date(System.currentTimeMillis()));
            while
 
 (Boolean.TRUE) {
                Job poll = null;
                boolean pollTimeOut = false;
                long startTime;
                long endTime;
                try {
                    // poll時設定超時時間為30秒
                    poll = dataQueue.poll(30, TimeUnit.SECONDS);
                } catch (InterruptedException e) {
                    LOGGER.info("批量更新Job異常");
                    Thread.currentThread().interrupt();
                }

                if (null != poll) {
                    // poll到任務新增到List中
                    jobs.add(poll);
                } else {
                    // poll超時，設定超時標誌位
                    pollTimeOut = true;
                }

                // 如果任務List等於5000或poll超時且List中還有任務就批量更新
                if (jobs.size() == 5000 || (pollTimeOut && !CollectionUtils.isEmpty(jobs))) {
                    startTime = System.currentTimeMillis();
                    jobMapper.batchUpdateByPrimaryKeySelective(jobs);
                    endTime = System.currentTimeMillis();
                    LOGGER.info("Job任務批量更新{}條任務,耗時{}毫秒", jobs.size(), endTime-startTime);
                    jobs.clear();
                }
            }
        });

        thread.setName("job-batchUpdate-deamon");
        // 設定啟動的執行緒為守護執行緒
        thread.setDaemon(true);
        thread.start();
    }
}

生產者方法就不說了，主要說消費者方法：

1. @PostConstruct作用是在Bean初始化之前執行消費者方法
2. poll = dataQueue.poll(30, TimeUnit.SECONDS);
   使用阻塞佇列的poll方法，設定poll超時時間，當超過時間返回一個null值
3. jobs.size() == 5000，如果List中值等於5000了就執行批量更新
4. pollTimeOut && !CollectionUtils.isEmpty(jobs)，如果poll超時了，說明當前生產者暫時沒有生產任務或不再生產任務，把List中剩餘的任務批量更新

5. thread.setDaemon(true)，設定執行緒為守護執行緒，直到jvm停了才停止

   Mysql批量更新實現

   <update id="batchUpdateByPrimaryKeySelective" parameterType="java.util.List">
       update abacus_job
       <trim prefix="set" suffixOverrides=",">
           <trim prefix="status =case" suffix="end,">
               <foreach collection="jobs" item="it" index="index">
                   when job_id=#{it.jobId,jdbcType=BIGINT} then #{it.status,jdbcType=TINYINT}
               </foreach>
           </trim>
           <trim prefix="result =case" suffix="end,">
               <foreach collection="jobs" item="it" index="index">
                   when job_id=#{it.jobId,jdbcType=BIGINT} then #{it.result,jdbcType=VARCHAR}
               </foreach>
           </trim>
       </trim>
       where job_id in
       <foreach collection="jobs" index="index" item="it" separator="," open="(" close=")">
           #{it.jobId,jdbcType=BIGINT}
       </foreach>
   </update>

   實際生成出來的SQL語句像以下格式：

   update abacus_job
    set status =
    case when job_id=1 then 1
            when job_id=2 then 2
            ...
    end,
    set result =
    case when job_id=1 then 'true'
            when job_id=2 then false
            ...
    end
   where job_id in (1, 2...)

   其實mysql批量更新還有一種寫法：

   <update id="batchUpdateByPrimaryKeySelective" parameterType="java.util.List">
   <foreach collection="jobs" item="item" index="index" open="" close="" separator=";">
     update abacus_job
     <set>
       <if test="item.status != null">
         status = #{item.status,jdbcType=TINYINT},
       </if>
       <if test="item.result != null">
         result = #{item.result,jdbcType=VARCHAR},
       </if>
     </set>
     where job_id = #{item.jobId,jdbcType=BIGINT}
   </foreach>
   </update>

   這樣生成的SQL是這樣：

   update abacus_job set status = 1, result = 'true' where job_id = 1;
   update abacus_job set status = 2, result = 'false' where job_id = 2;

   其實第二種方式的執行效率比第一種好，但是由於用了公司的資料連線中介軟體來做分表，用第二種方式更新的話，公司的中介軟體不支援，只好使用第一種，具體情況明天測試之後再看。

最近工作起來很費勁，感覺腦子不好使了，啥都容易忘，也是自己一直沒怎麼用心學，hold不住了，生活不止眼前的苟且，還有左右和後邊的苟且。

特別鳴謝一直陪伴在身邊的陳美美！！！