聊聊artemis的transactionTimeoutScanPeriod

public class ConfigurationImpl implements Configuration, Serializable {
​
   //......
​
   private long transactionTimeoutScanPeriod = ActiveMQDefaultConfiguration.getDefaultTransactionTimeoutScanPeriod();
​
   //......
​
   @Override
   public long getTransactionTimeoutScanPeriod() {
      return transactionTimeoutScanPeriod;
   }
​
   @Override
   public ConfigurationImpl setTransactionTimeoutScanPeriod(final long period) {
      transactionTimeoutScanPeriod = period;
      return this;
   }
​
   //......
}

public class ActiveMQServerImpl implements ActiveMQServer {
​
   //......
    
   synchronized boolean initialisePart1(boolean scalingDown) throws Exception {
    
      //......
​
      resourceManager = new ResourceManagerImpl((int) (configuration.getTransactionTimeout() / 1000), configuration.getTransactionTimeoutScanPeriod(), scheduledPool);
​
       //......
   }
​
   //......
}

public class ResourceManagerImpl implements ResourceManager {
​
   private final ConcurrentMap<Xid, Transaction> transactions = new ConcurrentHashMap<>();
​
   private final List<HeuristicCompletionHolder> heuristicCompletions = new ArrayList<>();
​
   private final int defaultTimeoutSeconds;
​
   private boolean started = false;
​
   private TxTimeoutHandler task;
​
   private final long txTimeoutScanPeriod;
​
   private final ScheduledExecutorService scheduledThreadPool;
​
   public ResourceManagerImpl(final int defaultTimeoutSeconds,
                              final long txTimeoutScanPeriod,
                              final ScheduledExecutorService scheduledThreadPool) {
      this.defaultTimeoutSeconds = defaultTimeoutSeconds;
      this.txTimeoutScanPeriod = txTimeoutScanPeriod;
      this.scheduledThreadPool = scheduledThreadPool;
   }
​
   // ActiveMQComponent implementation
​
   @Override
   public int size() {
      return transactions.size();
   }
​
   @Override
   public void start() throws Exception {
      if (started) {
         return;
      }
      task = new TxTimeoutHandler();
      Future<?> future = scheduledThreadPool.scheduleAtFixedRate(task, txTimeoutScanPeriod, txTimeoutScanPeriod, TimeUnit.MILLISECONDS);
      task.setFuture(future);
​
      started = true;
   }
​
   @Override
   public void stop() throws Exception {
      if (!started) {
         return;
      }
      if (task != null) {
         task.close();
      }
​
      started = false;
   }
​
   //......
}

   private class TxTimeoutHandler implements Runnable {
​
      private boolean closed = false;
​
      private Future<?> future;
​
      @Override
      public void run() {
         if (closed) {
            return;
         }
​
         Set<Transaction> timedoutTransactions = new HashSet<>();
​
         long now = System.currentTimeMillis();
​
         for (Transaction tx : transactions.values()) {
​
            if (tx.hasTimedOut(now, defaultTimeoutSeconds)) {
               Transaction removedTX = removeTransaction(tx.getXid());
               if (removedTX != null) {
                  ActiveMQServerLogger.LOGGER.timedOutXID(removedTX.getXid());
                  timedoutTransactions.add(removedTX);
               }
            }
         }
​
         for (Transaction failedTransaction : timedoutTransactions) {
            try {
               failedTransaction.rollback();
            } catch (Exception e) {
               ActiveMQServerLogger.LOGGER.errorTimingOutTX(e, failedTransaction.getXid());
            }
         }
      }
​
      synchronized void setFuture(final Future<?> future) {
         this.future = future;
      }
​
      void close() {
         if (future != null) {
            future.cancel(false);
         }
​
         closed = true;
      }
​
   }