Transactions EJB定时器长时间运行方法和Weblogic 10.3.4问题

我有一个EJB定时器3.0，这个定时器有一个方法，每次调用大约运行6个小时。我实现的计时器如下所示：

@Stateless
@TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)
public class BatchJobConsumerTimer implements BatchJobConsumerTimerLocal {

@Resource
TimerService timerService;

@EJB
ModelOperationsLocal modelOperations;

private static final long ONE_DAY_IN_MILLISECONDS = 86400000L;

private static final Logger LOG = Logger
        .getLogger(BatchJobConsumerTimer.class);

public BatchJobConsumerTimer() {
}

@Timeout
public void timeout(Timer timer) {
    LOG.info("Entering timeout method.");
    if(TimerRunningChecker.isWorking()){
        LOG.warn("A TIMER ALREADY IS RUNNING, SECOND TIMER WANTS TO ENTER TIMEOUT METHOD");
        return;
    } else {
        TimerRunningChecker.setWorking(true);
    }

    TimerConfiguration timerConfiguration = (TimerConfiguration) timer
            .getInfo();
    if (timerConfiguration != null) {
        Calendar calendar = new GregorianCalendar();
        if (isWorkDay(timerConfiguration.getSelectedDays())) {
            Date startTime = new Date(System.currentTimeMillis());
            Boolean and = timerConfiguration.getAnd();
            Integer numberOfJobs = timerConfiguration.getNumberOfJobs();

            int jobConsumed = 0;

            INFINITE: while (true) {
                List<Job> findWaitingJobs = modelOperations
                        .getLatestUploadedWaitingBatchJobs((numberOfJobs == -1 || numberOfJobs > 100) ? 100
                                : numberOfJobs);
                if (findWaitingJobs != null) {
                    if(findWaitingJobs.size() == 0){
                        LOG.warn("There is no jobs to consume.");
                        break INFINITE;
                    }
                    for (Job job : findWaitingJobs) {
                        ++jobConsumed;// means successful and unsuccessful
                        LOG.info("Job Number: " + (jobConsumed));
                        if (and) {
                            if (numberOfJobs != -1) {

                                if (jobConsumed > numberOfJobs
                                        && isEqualsAfterEndSchedule(
                                                calendar,
                                                timerConfiguration)) {
                                    LOG.info("jobConsumed > numberOfJobs && isEqualsAfterEndSchedule(calendar) is true");
                                    break INFINITE;
                                }
                            } else {
                                if (isEqualsAfterEndSchedule(calendar,
                                        timerConfiguration)) {
                                    LOG.info("numberOfJobs = infinite && isEqualsAfterEndSchedule(calendar) is true");
                                    break INFINITE;
                                }
                            }
                        } else {
                            if (numberOfJobs != -1) {
                                if (jobConsumed > numberOfJobs
                                        || isEqualsAfterEndSchedule(
                                                calendar,
                                                timerConfiguration)) {
                                    LOG.info("jobConsumed > numberOfJobs || isEqualsAfterEndSchedule(calendar) is true");
                                    break INFINITE;
                                }
                            } else {
                                if (isEqualsAfterEndSchedule(calendar,
                                        timerConfiguration)) {
                                    LOG.info("numberOfJobs = infinite || isEqualsAfterEndSchedule(calendar) is true");
                                    break INFINITE;
                                }
                            }
                        }

                        try {
                            LOG.info(job.getServiceNumber()
                                    + " hizmet numarali is tuketilicek.");

                            modelOperations.update(job);
                        } catch (Exception e) {
                            LOG.error(e, e);
                        }
                    }
                } else {
                    // liste bos don method'dan
                    break INFINITE;
                }
            }

            //send email
            Date endTime = new Date(System.currentTimeMillis());
            try {
                modelOperations.sendBatchOperationMail(startTime, endTime);
            } catch (Exception e) {
                LOG.error(e, e);
            }
        } else {
            LOG.warn("Today is not the working day.");
        }
    } else {
        LOG.warn("TimerConfiguration is not set.");
    }

    if(!TimerRunningChecker.isWorking()){
        LOG.warn("A TIMER WANTS CHANGE THE STATE OF WORKING TO NOT WORKING STATE, BUT IT IS ALREADY SET NOT WORKING STATE");
        return;
    } else {
        TimerRunningChecker.setWorking(false);
    }
    LOG.info("Exiting timout method.");
}

@Override
public void createTimer(TimerConfiguration timerConfiguration)
        throws Exception {
    // stop the other timers.
    Collection<Timer> timers = timerService.getTimers();
    for (Timer timer : timers) {
        timer.cancel();
    }

    timerService.createTimer(
            getRemainingTimeToFirstExpiration(timerConfiguration),
            ONE_DAY_IN_MILLISECONDS, timerConfiguration);
}

private long getRemainingTimeToFirstExpiration(
        TimerConfiguration timerConfiguration) {
    Calendar now = new GregorianCalendar();
    Calendar nextStart = new GregorianCalendar();
    nextStart.set(Calendar.HOUR_OF_DAY, timerConfiguration.getBeginHour());
    nextStart.set(Calendar.MINUTE, timerConfiguration.getBeginMinute());
    nextStart.set(Calendar.SECOND, timerConfiguration.getBeginSecond());

    long diff = nextStart.getTimeInMillis() - now.getTimeInMillis();
    return (diff < 0 ? diff + ONE_DAY_IN_MILLISECONDS : diff);
}

private boolean isEqualsAfterEndSchedule(Calendar calendar,
        TimerConfiguration timerConfiguration) {
    calendar.setTimeInMillis(System.currentTimeMillis());
    int currentHour = calendar.get(Calendar.HOUR_OF_DAY);
    int currentMinute = calendar.get(Calendar.MINUTE);
    int currentSecond = calendar.get(Calendar.SECOND);

    if (currentHour > timerConfiguration.getEndHour()) {
        return true;
    } else if (currentHour == timerConfiguration.getEndHour()) {
        if (currentMinute > timerConfiguration.getEndMinute()) {
            return true;
        } else if (currentMinute == timerConfiguration.getEndMinute()) {
            if (currentSecond >= timerConfiguration.getEndSecond()) {
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    } else {
        return false;
    }
}

private boolean isWorkDay(String selectedDays) {
    if(selectedDays == null){
        LOG.error("selectedDays is NULL!");
        return false;
    }

    LOG.info("selectedDays: " + selectedDays);
    if (selectedDays.equals("?")) {
        return false;
    }

    if (selectedDays.equals("*")) {
        return true;
    }

    Calendar now = GregorianCalendar.getInstance();

    int i = now.get(Calendar.DAY_OF_WEEK);
    LOG.info("now.get(Calendar.DAY_OF_WEEK): " + i);
    if (selectedDays.contains("" + i)) {
        return true;
    } else {
        return false;
    }
}
}  

@无状态
@TransactionAttribute（不支持TransactionAttribute类型）
公共类BatchJobConsumerTimer实现BatchJobConsumerTimerLocal{
@资源
TimerService TimerService；
@EJB
模型操作本地模型操作；
专用静态最终长一天（单位：毫秒）=86400000L；
专用静态最终记录器日志=记录器
.getLogger（BatchJobConsumerTime.class）；
公共批处理JobConsumerTimer（）{
}
@超时
公共无效超时（计时器）{
LOG.info（“输入超时方法”）；
if（TimerRunningChecker.isWorking（））{
LOG.warn（“一个计时器已经在运行，第二个计时器想要输入超时方法”）；
返回；
}否则{
TimerRunningChecker.setWorking（真）；
}
TimerConfiguration TimerConfiguration=（TimerConfiguration）计时器
.getInfo（）；
if（timerConfiguration！=null）{
日历=新的公历日历（）；
if（isWorkDay（timerConfiguration.getSelectedDays（））{
日期开始时间=新日期（System.currentTimeMillis（））；
布尔and=timerConfiguration.getAnd（）；
整数numberOfJobs=timerConfiguration.getNumberOfJobs（）；
int=0；
无限：while（true）{
列出findWaitingJobs=modelOperations
.getLatestUploadedWaitingBatchJobs（（numberOfJobs==-1 | | numberOfJobs>100）？100
：职位数目）；
if（findWaitingJobs！=null）{
if（findWaitingJobs.size（）==0）{
LOG.warn（“没有可使用的作业”）；
打破无限；
}
for（作业：findWaitingJobs）{
++jobConsumed；//表示成功和不成功
LOG.info（“作业编号：”+（作业消耗））；
若（及）{
如果（作业数！=-1）{
如果（作业已消耗>作业数）
&&isEqualsAfterEndSchedule(
日历，
时间配置）{
LOG.info（“jobConsumed>numberOfJobs&&isEqualsAfterEndSchedule（calendar）为true”）；
打破无限；
}
}否则{
如果（isEqualsAfterEndSchedule）（日历，
时间配置）{
LOG.info（“numberOfJobs=infinite&&isEqualsAfterEndSchedule（calendar）为true”）；
打破无限；
}
}
}否则{
如果（作业数！=-1）{
如果（作业已消耗>作业数）
||isEqualsAfterEndSchedule(
日历，
时间配置）{
LOG.info（“jobConsumed>numberOfJobs | | isEqualsAfterEndSchedule（calendar）为true”）；
打破无限；
}
}否则{
如果（isEqualsAfterEndSchedule）（日历，
时间配置）{
LOG.info（“numberOfJobs=infinite | | isEqualsAfterEndSchedule（calendar）为true”）；
打破无限；
}
}
}
试一试{
LOG.info（job.getServiceNumber（）
+“hizmet numarali是tuketilicek。”）；
modelOperations.update（作业）；
}捕获（例外e）{
日志错误（e，e）；
}
}
}否则{
//李斯特·博斯·唐丹
打破无限；
}
}
//发送电子邮件
Date endTime=新日期（System.currentTimeMillis（））；
试一试{
sendBatchOperationMail（开始时间、结束时间）；
}捕获（例外e）{
日志错误（e，e）；
}
}否则{
LOG.warn（“今天不是工作日”）；
}
}否则{
LOG.warn（“未设置TimerConfiguration.”）；
}
如果（！TimerRunningChecker.isWorking（））{
LOG.warn（“计时器希望将工作状态更改为非工作状态，但已设置为非工作状态”）；
返回；
}否则{
TimerRunningChecker.setWorking（假）；
}
LOG.info（“退出超时方法”）；
}
@凌驾
公共无效createTimer（TimerConfiguration TimerConfiguration）
抛出异常{
//停止其他计时器。
Collection timers=timerService.getTimers（）；
用于（计时器：计时器）{
timer.cancel（）；
}
timerService.createTimer(
getRemainingTimeToFirstExpiration（时间配置），
一天（以毫秒为单位，时间配置）；
}
私人长getRemainingTimeToFirstExpiration(
时间配置（时间配置）{
Calendar now=新的GregorianCalendar（）；
Calendar nextStart=新的GregorianCalendar（）；
nextStart.set（Calendar.HOUR OF_DAY，timerConfiguration.getBeginHour（））；
nextStart.set（Calendar.MINUTE，timerConfiguration.getBeginMinute（））；
nextStart.set（C
@Stateless 

@Local(TimerBusinessService.class)
@TransactionManagement(TransactionManagementType.BEAN)
public class TimerBusinessServiceImpl implements TimerBusinessService {

    @Resource
    private TimerService timerService;

    @EJB
    private NonTxService nonTxService;

    @Override
    public void doStartTimer() throws EjpdBusinessException {
        long everyDay = 86400000;...
        timerService.createTimer(0, everyDay, ...);
    }           

    @Timeout
    public void periodicalTimerMethode(Timer timer) throws EjpdBusinessException {
        try {
            nonTxService.proceedAction ();
        } catch (…Exception ex) {
            throw new RuntimeException(“..”, ex);
        }
    }
}