How to use org.datacleaner.job.concurrent

@Override
public void onError(final Task task, final Throwable throwable) {
  for (final TaskListener listener : _listeners) {
    listener.onError(task, throwable);
  }
}

@Override
public void onBegin(final Task task) {
  if (_nextTaskListener != null) {
    _nextTaskListener.onBegin(task);
  }
}

@Override
public void onComplete(final Task task) {
  for (final TaskListener listener : _listeners) {
    listener.onComplete(task);
  }
}

/**
 * Default constructor. Will perform classpath scanning in the calling thread(s).
 */
public ClasspathScanDescriptorProvider() {
  this(new SingleThreadedTaskRunner());
}

  private void invokeNested(final int count, final Task task) {
    if (count == 0) {
      if (_error == null) {
        logger.debug("Calling onComplete(...) on nested TaskListener ()");
        _nestedTaskListener.onComplete(task);
      } else {
        logger.debug("Calling onError(...) on nested TaskListener ()");
        _nestedTaskListener.onError(task, _error);
      }
    }
  }
}

@Override
public void run(final Task task, final TaskListener taskListener) {
  if (isErrornous()) {
    taskListener.onError(task, _previousErrorsExistException);
  } else if (isCancelled()) {
    logger.info("Ignoring task because job has been cancelled: {}", task);
    taskListener.onError(task, _previousErrorsExistException);
  } else {
    _taskRunner.run(task, taskListener);
  }
}

@Override
public void shutdown() {
  _taskRunner.shutdown();
}

  @Override
  public void onError(final Task task, final Throwable throwable) {
    for (final TaskRunnable tr : _tasks) {
      final TaskListener listener = tr.getListener();
      if (listener == null) {
        logger.warn("TaskListener for {} was null", tr);
      } else {
        listener.onError(task, throwable);
      }
    }
  }
}

@Override
protected boolean runRowProcessingInternal(final List<TaskRunnable> postProcessingTasks) {
  final TaskListener runCompletionListener =
      new ForkTaskListener("run row processing (" + getStream() + ")", getTaskRunner(), postProcessingTasks);
  final RowProcessingMetrics rowProcessingMetrics = getRowProcessingMetrics();
  final RunRowProcessingPublisherTask runTask = new RunRowProcessingPublisherTask(this, rowProcessingMetrics);
  getTaskRunner().run(runTask, runCompletionListener);
  return true;
}

@Override
public void onComplete(final Task task) {
  _taskRunner.run(_nextTask, _nextListener);
}

@Override
public void run(final Task task, final TaskListener listener) {
  logger.debug("run({},{})", task, listener);
  executeInternal(new TaskRunnable(task, listener));
}

  @Override
  protected boolean runRowProcessingInternal(final List<TaskRunnable> postProcessingTasks) {
    final TaskListener runCompletionListener =
        new ForkTaskListener("run row processing (" + getStream() + ")", getTaskRunner(), postProcessingTasks);

    final RowProcessingMetrics rowProcessingMetrics = getRowProcessingMetrics();
    final RunRowProcessingPublisherTask runTask = new RunRowProcessingPublisherTask(this, rowProcessingMetrics);

    final TaskListener initFinishedListener =
        new RunNextTaskTaskListener(getTaskRunner(), runTask, runCompletionListener);

    // kick off the initialization
    initializeConsumers(initFinishedListener);

    return true;
  }
}

@Override
public boolean isDone() {
  if (!_done) {
    _done = _jobTaskListener.isDone();
  }
  return _done;
}

@Override
public Date getCreationDate() {
  return _jobTaskListener.getCompletionTime();
}

@Override
protected void finalize() throws Throwable {
  shutdown();
}

public JoinTaskListener(final int tasksToWaitFor, final TaskListener... nestedTaskListeners) {
  this(tasksToWaitFor, new CompositeTaskListener(nestedTaskListeners));
}

@Override
public void run(final TaskRunnable taskRunnable) {
  logger.debug("run({})", taskRunnable);
  executeInternal(taskRunnable);
}

public static TaskRunner defaultTaskRunner() {
  return new SingleThreadedTaskRunner();
}

@Override
public void onError(final Task task, final Throwable throwable) {
  _nextListener.onError(task, throwable);
}

@Override
public void onBegin(final Task task) {
  for (final TaskListener listener : _listeners) {
    listener.onBegin(task);
  }
}