Package org.kuali.rice.kcb.quartz

Class ConcurrentJob<T>

java.lang.Object
org.kuali.rice.kcb.quartz.ConcurrentJob<T>
Direct Known Subclasses:
MessageProcessingJob
public abstract class ConcurrentJob<T> extends Object
Base class for jobs that must obtain a set of work items atomically
Author:
Kuali Rice Team (rice.collab@kuali.org)

  • Field Details

    • LOG

      protected final org.apache.logging.log4j.Logger LOG

    • executor

      protected ExecutorService executor

    • txManager

      protected org.springframework.transaction.PlatformTransactionManager txManager

  • Constructor Details

    • ConcurrentJob

      public ConcurrentJob()

  • Method Details

    • setExecutorService

      public void setExecutorService(ExecutorService executor)
      Sets the ExecutorService to use to process work items. Default is single-threaded.
      Parameters:
      executor - the ExecutorService to use to process work items. Default is single-threaded.

    • setTransactionManager

      public void setTransactionManager(org.springframework.transaction.PlatformTransactionManager txManager)
      Sets the PlatformTransactionManager
      Parameters:
      txManager - the PlatformTransactionManager

    • createNewTransaction

      protected org.springframework.transaction.support.TransactionTemplate createNewTransaction()
      Helper method for creating a TransactionTemplate initialized to create a new transaction
      Returns:
      a TransactionTemplate initialized to create a new transaction

    • takeAvailableWorkItems

      protected abstract Collection<T> takeAvailableWorkItems()
      Template method that subclasses should override to obtain a set of available work items and mark them as taken
      Returns:
      a collection of available work items that have been marked as taken

    • groupWorkItems

      protected Collection<Collection<T>> groupWorkItems(Collection<T> workItems, ProcessingResult<T> result)
      Template method that subclasses should override to group work items into units of work
      Parameters:
      workItems - list of work items to break into groups
      result - ProcessingResult to modify if there are any failures...this is sort of a hack because previously failure to obtain a deliverer was considered a work item failure, and now this method has been factored out... but the tests still want to see the failure
      Returns:
      a collection of collection of work items

    • processWorkItems

      protected abstract Collection<T> processWorkItems(Collection<T> items)
      Template method that subclasses should override to process a given work item and mark it as untaken afterwards
      Parameters:
      item - the work item
      Returns:
      a collection of success messages

    • unlockWorkItem

      protected abstract void unlockWorkItem(T item)
      Template method that subclasses should override to unlock a given work item when procesing has failed.
      Parameters:
      item - the work item to unlock

    • run

      public ProcessingResult<T> run()
      Main processing method which invokes subclass implementations of template methods to obtain available work items, and process them concurrently
      Returns:
      a ProcessingResult object containing the results of processing

    • finishProcessing

      protected void finishProcessing(ProcessingResult<T> result)
      Template method called after processing of work items has completed

    • unlockWorkItemAtomically

      protected void unlockWorkItemAtomically(T workItem)

    • executeInTransaction

      protected <X> X executeInTransaction(org.springframework.transaction.support.TransactionCallback callback)