org.kuali.rice.ken.service.impl
Class ConcurrentJob<T>

java.lang.Object
  extended by org.kuali.rice.ken.service.impl.ConcurrentJob<T>
Direct Known Subclasses:
NotificationMessageDeliveryAutoRemovalServiceImpl, NotificationMessageDeliveryResolverServiceImpl

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 Summary
protected  ExecutorService executor
           
protected  org.apache.log4j.Logger LOG
           
protected  org.springframework.transaction.PlatformTransactionManager txManager
           
 
Constructor Summary
ConcurrentJob(org.springframework.transaction.PlatformTransactionManager txManager, ExecutorService executor)
          Constructs a ConcurrentJob instance.
 
Method Summary
protected  org.springframework.transaction.support.TransactionTemplate createNewTransaction()
          Helper method for creating a TransactionTemplate initialized to create a new transaction
protected  Collection<Collection<T>> groupWorkItems(Collection<T> workItems, ProcessingResult result)
          Template method that subclasses should override to group work items into units of work
protected abstract  Collection<?> processWorkItems(Collection<T> items)
          Template method that subclasses should override to process a given work item and mark it as untaken afterwards
 ProcessingResult run()
          Main processing method which invokes subclass implementations of template methods to obtain available work items, and process them concurrently
protected abstract  Collection<T> takeAvailableWorkItems()
          Template method that subclasses should override to obtain a set of available work items and mark them as taken
protected abstract  void unlockWorkItem(T item)
          Template method that subclasses should override to unlock a given work item when procesing has failed.
protected  void unlockWorkItemAtomically(T workItem)
           
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

LOG

protected final org.apache.log4j.Logger LOG

executor

protected ExecutorService executor

txManager

protected org.springframework.transaction.PlatformTransactionManager txManager
Constructor Detail

ConcurrentJob

public ConcurrentJob(org.springframework.transaction.PlatformTransactionManager txManager,
                     ExecutorService executor)
Constructs a ConcurrentJob instance.

Parameters:
txManager - PlatformTransactionManager to use for transactions
executor - the ExecutorService to use to process work items
Method Detail

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 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<?> 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 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

unlockWorkItemAtomically

protected void unlockWorkItemAtomically(T workItem)


Copyright © 2004-2012 The Kuali Foundation. All Rights Reserved.