/** Release any locally allocated sequence back to the global sequence pool. */
void afterCommitInternal(Map localSequences, Accessor accessor) {
Iterator it = localSequences.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
String seqName = (String) entry.getKey();
Vector localSequenceForName = (Vector) entry.getValue();
if (!localSequenceForName.isEmpty()) {
getPreallocationHandler().setPreallocated(seqName, localSequenceForName);
// clear all localSequencesForName
localSequenceForName.clear();
}
}
if (accessor != null) {
getOwnerSession()
.log(
SessionLog.FINEST,
SessionLog.SEQUENCING,
"sequencing_afterTransactionCommitted",
null,
accessor);
} else {
getOwnerSession()
.log(
SessionLog.FINEST,
SessionLog.SEQUENCING,
"sequencing_afterTransactionCommitted",
null);
}
}
/**
* Return the next sequence value. First check the global pool, if empty then allocate new
* sequences locally.
*/
public Object getNextValue(Sequence sequence, AbstractSession writeSession) {
String seqName = sequence.getName();
if (sequence.getPreallocationSize() > 1) {
Queue sequencesForName = getPreallocationHandler().getPreallocated(seqName);
// First grab the first sequence value without locking, a lock is only required if empty.
Object sequenceValue = sequencesForName.poll();
if (sequenceValue != null) {
return sequenceValue;
}
// KeepLocked indicates whether the sequence lock should be kept for the whole duration of
// this method.
// Of course the lock should be released in any case when the method returns or throws an
// exception.
// This is only used if a sequence transaction was begun by the unit of work,
// and will be committed before the unit of work commit.
boolean keepLocked = false;
if (!getOwnerSession().getDatasourceLogin().shouldUseExternalTransactionController()
&& !writeSession.isInTransaction()) {
// To prevent several threads from simultaneously allocating a separate bunch of
// sequencing numbers each. With keepLocked==true the first thread locks out others
// until it copies the obtained sequence numbers to the global storage.
// Note that this optimization possible only in non-jts case when there is no transaction.
acquireLock(seqName);
try {
sequenceValue = sequencesForName.poll();
if (sequenceValue != null) {
return sequenceValue;
}
writeSession.beginTransaction(); // write accessor is set in begin
keepLocked = true;
} finally {
if (!keepLocked) {
releaseLock(seqName);
}
}
}
Accessor accessor;
Vector localSequencesForName;
if (!keepLocked) {
writeSession.beginTransaction(); // write accessor is set in begin
}
try {
accessor = writeSession.getAccessor();
SequencingCallbackImpl seqCallbackImpl = getCallbackImpl(writeSession, accessor);
Map localSequences = seqCallbackImpl.getPreallocatedSequenceValues();
localSequencesForName = (Vector) localSequences.get(seqName);
if ((localSequencesForName == null) || localSequencesForName.isEmpty()) {
localSequencesForName = sequence.getGeneratedVector(null, writeSession);
localSequences.put(seqName, localSequencesForName);
logDebugLocalPreallocation(writeSession, seqName, localSequencesForName, accessor);
}
} catch (RuntimeException ex) {
if (keepLocked) {
releaseLock(seqName);
}
try {
// make sure to rollback the transaction we've begun
writeSession.rollbackTransaction();
} catch (Exception rollbackException) {
// ignore rollback exception
}
// don't eat the original exception
throw ex;
}
try {
try {
// commitTransaction may copy preallocated sequence numbers
// from localSequences to preallocationHandler: that happens
// if it isn't a nested transaction, and sequencingCallback.afterCommit
// method has been called.
// In this case:
// 1. localSequences corresponding to the accessor
// has been removed from accessorToPreallocated;
// 2. All its members are empty (therefore localSequenceForName is empty).
writeSession.commitTransaction();
} catch (DatabaseException ex) {
try {
// make sure to rollback the transaction we've begun
writeSession.rollbackTransaction();
} catch (Exception rollbackException) {
// ignore rollback exception
}
// don't eat the original exception
throw ex;
}
if (!localSequencesForName.isEmpty()) {
// localSeqencesForName is not empty, that means
// sequencingCallback has not been called.
sequenceValue = localSequencesForName.remove(0);
return sequenceValue;
} else {
// localSeqencesForName is empty, that means
// sequencingCallback has been called.
sequenceValue = sequencesForName.poll();
if (sequenceValue != null) {
return sequenceValue;
}
return getNextValue(sequence, writeSession);
}
} finally {
if (keepLocked) {
releaseLock(seqName);
}
}
} else {
writeSession.beginTransaction();
try {
// preallocation size is 1 - just return the first (and only) element of the allocated
// vector.
Object sequenceValue = sequence.getGeneratedVector(null, writeSession).firstElement();
writeSession.commitTransaction();
return sequenceValue;
} catch (RuntimeException ex) {
try {
// make sure to rollback the transaction we've begun
writeSession.rollbackTransaction();
} catch (Exception rollbackException) {
// ignore rollback exception
}
// don't eat the original exception
throw ex;
}
}
}