2

我正在用 jBeret 编写一个 jBatch 程序。我目前正在这样做。

final JobOperator operator = BatchRuntime.getJobOperator();
logger.debug("operator: {}", operator);

final long id = operator.start("some", null);
logger.debug("id: {}", id);

final JobExecution execution = operator.getJobExecution(id);
logger.debug("execution: {}", execution);

问题是执行似乎是异步运行的，主要方法只是返回。

我能做的最好的就是循环直到退出状态不为空。

String status;
while ((status = execution.getExitStatus()) == null) {
    //logger.debug("sleeping");
    Thread.sleep(1000L);
}
logger.debug("status: {}", status);

有没有其他方法可以做到这一点？

4

3 回答 3

3

如果您需要block-and-wait，正如您所描述的，没有其他选择，但有类似的awaiCompletion()实现。

您的循环方法可以改进。让我们ThreadPoolExecutor作为一个例子。它有以下方法：

    /**
     * Blocks until all tasks have completed execution after a shutdown
     * request, or the timeout occurs, or the current thread is
     * interrupted, whichever happens first.
     *
     * @param timeout the maximum time to wait
     * @param unit the time unit of the timeout argument
     * @return {@code true} if this executor terminated and
     *         {@code false} if the timeout elapsed before termination
     * @throws InterruptedException if interrupted while waiting
     */
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

这是实现：

    public boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (;;) {
                if (runStateAtLeast(ctl.get(), TERMINATED))
                    return true;
                if (nanos <= 0)
                    return false;
                nanos = termination.awaitNanos(nanos);
            }
        } finally {
            mainLock.unlock();
        }
    }

请注意：

  • 无限循环应始终定义退出条件
  • 在您的情况下，超时是必须的，因为您不太可能准备好无休止的等待
  • 自然你必须知道是超时还是工作终止

所以，这是一个改编版本：

    public static boolean awaitTermination(JobExecution execution, long timeout) throws InterruptedException {
        final long limit = System.currentTimeMillis() + timeout;
        for (;;) {
            if (null != execution.getExitStatus()) {
                return true;
            }

            if (System.currentTimeMillis() >= limit) {
                return false;
            }

            Thread.sleep(timeout/10);            
        }
    }
于 2015-09-15T12:28:30.237 回答
2

JBeret 有一个内部方法：

org.jberet.runtime.JobExecutionImpl#awaitTermination(long timeout, TimeUnit timeUnit);

为了这个目的。

使用 JBeret 运行时，您可以在从启动作业获得的 JobExecution 上调用该方法。

于 2016-09-26T22:39:11.867 回答
1

您可以实现JobListener类，或者只是扩展AbstractJobListener：

...
public class MyJobListener extends AbstractJobListenerJobListener {

    // The afterJob method receives control after the job execution ends.
    @Override
    public void afterJob() throws Exception { ... }

    ...
}

在 afterJob 方法中，您可以使用一些基本的 Java 同步技术（Future 左右）。

于 2015-09-15T11:38:15.253 回答