|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
Transaction implementation that contains most of the plumbing logic.TransactionalDeque implementation.TransactionFactory with the provided configuration.
Latch based on the intrinsic lock and uses the minimal amount of resources.CyclicBarrier but
tailored to work with transactions.CommitLock should never by acquired directly, but always through the CommitLockPolicy.CommitLocks.TooManyRetriesException that is thrown when a
constructor wants to retry but isn't able to do.Error that is used to regulate control flow inside multiverse, to be more specific
jump from code to the handler the transaction management logic (instrumented or
SpeculativeConfigurationFailure) so it doesn't indicate a
bad thing.IllegalTransactionStateException that indicates that an action is executed on a
transaction that is committed or aborted.TransactionalReference.BackoffPolicy that does an exponential backoff.CommitLockPolicy that spins when it can't acquire a lock.TransactionConfiguration that is used by this Transaction.
Stm instance.
TransactionFactoryBuilder that needs to be used to execute transactions on this Stm.
Stm that is used globally.IllegalStateException that is thrown when an operations is executed on a
Transaction when it is not in a valid state for that operation.Future or a
CountDownLatch.ReadConflict that indicates that a read failed because the item was locked.WriteConflict that indicates that the locks could not be acquired while doing a
Transaction.commit().TransactionalObject to exclude it from being managed by
the STM.BackoffPolicy that does not backoff.IllegalTransactionStateException that indicates that a retry is done, without the
possibility of progress, for example when the readset is empty.IllegalStateException that can be thrown when no transaction but if it was expected.ReadConflict that indicates that a load was done, but the version needed could not be found
because it is too old (and doesn't exist anymore).WriteConflict that indicates that the version of the transactional object
you want to update already was updated by another transaction.Executor functionality.Error that is thrown if the system has entered an invalid state.CommitLockFilter that says that all locks need locking.IllegalTransactionStateException that is thrown when an operation is executed on a
transaction while the transaction is prepared.Error that indicates that a load a transactional object using a transaction failed.IllegalTransactionStateException that indicates that an action is executed on a
readonly transaction that requires an update.ControlFlowError that indicates that an explicit retry should be done, e.g.RuntimeException that is thrown in case of a transaction timeout
on a blocking operation (using the retry primitive).PrimitiveClock implementation that can be used in a single thread environment.ControlFlowError that indicates that current transaction implementation can't deal
with more transactional objects than it can handle.ThreadFactory.IllegalStateException that is thrown when a TransactionFactoryBuilder failed
to start a transaction.Stm or
Transaction.PrimitiveClock.ThreadLocal that contains the current Transaction.RuntimeException that is thrown when a transaction is retried too many times.TransactionalReference that doesn't suffer from the ABA problem.TransactionalList based on a (transactional) array.Collection interface.BlockingDeque interface.Executor.ExecutorService.Iterable
Collection
List
Queue
BlockingQueue
Deque
BlockingDeque
Each operation on this TransactionalLinkedList is transactional by default, and of course can participate in already
running transactions.TransactionalCollection that implements the List
interface.ConcurrentMap.BlockingQueue interface.Transaction.Set interface.Executor implementation that looks a lot like the
ThreadPoolExecutor.Transaction.Transaction.TransactionFactory.TransactionLifecycleListener it is possible to listen
to certain events in the transaction (aborting/committing).Transaction can be in.ThreadLocalTransaction.
ReadConflict that is thrown when an object is loaded but has not been committed yet.Error that indicates a failure while doing a Transaction.commit().WriteConflict that is thrown when a writeskew is detected and the transaction is
not allowed to commit and therefore aborted.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||