private static void Pause(String description) throws Exception {
Singletons.Log.Debug(
"Pausing for "
+ Settings.PAUSE_SECONDS
+ " seconds: "
+ description
+ ". Other threads may be processing these tasks.");
MiscUtilities.Sleep(Settings.PAUSE_SECONDS * 1000);
Singletons.Log.Debug("Done with pause: " + description + ".");
}
/**
* Executes a series of tasks that are "locked" such that only one thread should execute each.
* These are locked across multiple compute nodes as well.
*
* @param description Name of the series of tasks that will be executed
* @param lockedCallables Tasks that will be executed
* @throws Exception
*/
public static void ExecuteLockTasks(String description, ArrayList<LockedCallable> lockedCallables)
throws Exception {
MultiThreadedTaskHandler taskHandler = new MultiThreadedTaskHandler(description);
// Prepare the tasks to be executed
for (LockedCallable callable : lockedCallables) {
FileUtilities.CreateFileDirectoryIfNotExists(callable.StatusFilePath);
taskHandler.Add(callable);
}
try {
// See if any of the tasks returned a false value and if so, pause then retry
if (ListUtilities.AnyFalse(ListUtilities.CreateBooleanList(taskHandler.Execute()))) {
Pause(description);
ExecuteLockTasks(description, lockedCallables);
}
} catch (Exception ex) {
// If an exception occurred, log it, pause, then try again
Singletons.Log.Exception(ex);
Pause(description);
ExecuteLockTasks(description, lockedCallables);
}
}
/**
* Executes multiple callable objects in a multithreaded fashion
*
* @return Objects that are returned from each _callable object
* @throws Exception
*/
public ArrayList Execute() throws Exception {
if (_callables == null || _callables.size() == 0) return new ArrayList();
Singletons.Log.Debug(
"Attempting to share execution across "
+ _numThreads
+ " threads for "
+ _description
+ ".");
// Initialize the service
// ExecutorService service = Executors.newFixedThreadPool(_numThreads);
ExecutorService service = new TimeoutThreadPoolExecutor(_numThreads);
try {
ArrayList<Future<Object>> futures = new ArrayList<Future<Object>>();
// Submit each task to a queue to be executed
for (Callable<Object> callable : _callables) futures.add(service.submit(callable));
ArrayList results = new ArrayList();
// Parse through the results of the execution
for (Future<Object> future : futures) {
Object result = future.get();
if (result != null) results.add(result);
}
return results;
} catch (Exception ex) {
throw ex;
} finally {
// Very important to shut down the service
service.shutdown();
}
}
