import javax.persistence.LockTimeoutException; //导入依赖的package包/类
@Override
public TaskStatusInfo getTaskToRun(String nodeId) {
	List<TaskStatusInfo> tsi = listTasks(null, toRunTaskStatusFilter, 0, 0);
	if (tsi != null && !tsi.isEmpty()) {
		for (int i = tsi.size() - 1; i >= 0; i--) {
			TaskStatusInfo work = tsi.get(i);
			try {
				em.lock(work, LockModeType.PESSIMISTIC_WRITE);
				if (work.startTaskExecution(nodeId)) {
					return work;
				}
			} catch (LockTimeoutException e) {
				log.fine("Lock exception for task id=" + work.getId());
			}
		}
	}
	return null;
}
 

import javax.persistence.LockTimeoutException; //导入依赖的package包/类
@Override
public void heartbeat(String nodeId, Set<String> runningTasksId, long failoverTimeout) {
	List<TaskStatusInfo> tsi = listTasks(null, runningTaskStatusFilter, 0, 0);
	if (tsi != null && !tsi.isEmpty()) {
		long ct = System.currentTimeMillis();
		long ft = ct - failoverTimeout;
		for (TaskStatusInfo task : tsi) {
			try {
				em.lock(task, LockModeType.PESSIMISTIC_WRITE);
				if (task.getTaskStatus() == TaskStatus.RUNNING) {
					if (runningTasksId != null && runningTasksId.contains(task.getId())) {
						task.setHeartbeat(ct);
					} else {
						if (task.getHeartbeat() < ft) {
							changeTaskStatus(task.getId(), TaskStatus.FAILOVER, "Failover necessity detected by node '" + nodeId
									+ "' at " + ct + " due heartbeat timestamp " + task.getHeartbeat());
						}
					}
				}
			} catch (LockTimeoutException e) {
				log.fine("Lock exception for task id=" + task.getId());
			}
		}
	}
}
 

import javax.persistence.LockTimeoutException; //导入依赖的package包/类
@Override
public TaskStatusInfo getTaskToRun(String nodeId) {
	List<TaskStatusInfo> tsi = listTasks(null, toRunTaskStatusFilter, 0, 0);
	if (tsi != null && !tsi.isEmpty()) {
		for (int i = tsi.size() - 1; i >= 0; i--) {
			TaskStatusInfo work = tsi.get(i);
			if (taskIsRunnableNow(nodeId, work)) {
				try {
					em.lock(work, LockModeType.PESSIMISTIC_WRITE);
					if (work.startTaskExecution(nodeId)) {
						return work;
					}
				} catch (LockTimeoutException e) {
					log.fine("Lock exception for task id=" + work.getId());
				}
			}
		}
	}
	return null;
}
 

import javax.persistence.LockTimeoutException; //导入依赖的package包/类
/**
 * Convert the given runtime exception to an appropriate exception from the
 * {@code org.springframework.dao} hierarchy.
 * Return null if no translation is appropriate: any other exception may
 * have resulted from user code, and should not be translated.
 * <p>The most important cases like object not found or optimistic locking failure
 * are covered here. For more fine-granular conversion, JpaTransactionManager etc
 * support sophisticated translation of exceptions via a JpaDialect.
 * @param ex runtime exception that occurred
 * @return the corresponding DataAccessException instance,
 * or {@code null} if the exception should not be translated
 */
public static DataAccessException convertJpaAccessExceptionIfPossible(RuntimeException ex) {
	// Following the JPA specification, a persistence provider can also
	// throw these two exceptions, besides PersistenceException.
	if (ex instanceof IllegalStateException) {
		return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
	}
	if (ex instanceof IllegalArgumentException) {
		return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
	}

	// Check for well-known PersistenceException subclasses.
	if (ex instanceof EntityNotFoundException) {
		return new JpaObjectRetrievalFailureException((EntityNotFoundException) ex);
	}
	if (ex instanceof NoResultException) {
		return new EmptyResultDataAccessException(ex.getMessage(), 1, ex);
	}
	if (ex instanceof NonUniqueResultException) {
		return new IncorrectResultSizeDataAccessException(ex.getMessage(), 1, ex);
	}
	if (ex instanceof QueryTimeoutException) {
		return new org.springframework.dao.QueryTimeoutException(ex.getMessage(), ex);
	}
	if (ex instanceof LockTimeoutException) {
		return new CannotAcquireLockException(ex.getMessage(), ex);
	}
	if (ex instanceof PessimisticLockException) {
		return new PessimisticLockingFailureException(ex.getMessage(), ex);
	}
	if (ex instanceof OptimisticLockException) {
		return new JpaOptimisticLockingFailureException((OptimisticLockException) ex);
	}
	if (ex instanceof EntityExistsException) {
		return new DataIntegrityViolationException(ex.getMessage(), ex);
	}
	if (ex instanceof TransactionRequiredException) {
		return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
	}

	// If we have another kind of PersistenceException, throw it.
	if (ex instanceof PersistenceException) {
		return new JpaSystemException((PersistenceException) ex);
	}

	// If we get here, we have an exception that resulted from user code,
	// rather than the persistence provider, so we return null to indicate
	// that translation should not occur.
	return null;
}