Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
CheckedActionFactory
Manages the CheckedAction instances on a per transaction basis.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
ActionHierarchy
Class that represents the transaction hierarchy.
|
ActionManager |
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
CheckedAction
If an action attempts to terminate with threads still active we call an
instance of this class to determine what to do.
|
Reapable |
RecordList
This class manages instances of the classes derived from AbstractRecord in
the form of an ordered doubly-linked list.
|
SynchronizationRecord |
TransactionReaper
Class to record transactions with non-zero timeout values, and class to
implement a transaction reaper thread which terminates these transactions
once their timeout elapses.
|
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
TxStats
This class is used to maintain statistics on transactions that have been
created.
|
TxStatsMBean
MBean interface for monitoring transaction statistics.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
RecordList
This class manages instances of the classes derived from AbstractRecord in
the form of an ordered doubly-linked list.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
OnePhaseResource |
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
CheckedAction
If an action attempts to terminate with threads still active we call an
instance of this class to determine what to do.
|
CheckedActionFactory
Manages the CheckedAction instances on a per transaction basis.
|
Reapable |
TransactionReaper
Class to record transactions with non-zero timeout values, and class to
implement a transaction reaper thread which terminates these transactions
once their timeout elapses.
|
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
ExceptionDeferrer
In most cases resources defer exceptions and return an arjuna specific error code.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
ExceptionDeferrer
In most cases resources defer exceptions and return an arjuna specific error code.
|
OnePhaseResource |
SynchronizationRecord |
Class and Description |
---|
SynchronizationRecord |
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
ExceptionDeferrer
In most cases resources defer exceptions and return an arjuna specific error code.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
RecordList
This class manages instances of the classes derived from AbstractRecord in
the form of an ordered doubly-linked list.
|
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
Reapable |
Class and Description |
---|
CheckedAction
If an action attempts to terminate with threads still active we call an
instance of this class to determine what to do.
|
Class and Description |
---|
Reapable |
Class and Description |
---|
CheckedAction
If an action attempts to terminate with threads still active we call an
instance of this class to determine what to do.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Class and Description |
---|
CheckedAction
If an action attempts to terminate with threads still active we call an
instance of this class to determine what to do.
|
Class and Description |
---|
ActionHierarchy
Class that represents the transaction hierarchy.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
SynchronizationRecord |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
AbstractRecord
Abstract Record Class
This class provides an abstract template that defines the interface that the
atomic action system uses to notify objects that various state transitions
have occurred as the 2PC protocol executes.
|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Class and Description |
---|
BasicAction
BasicAction does most of the work of an atomic action, but does not manage
thread scoping.
|
Reapable |
TwoPhaseCoordinator
Adds support for synchronizations to BasicAction.
|
Copyright © 2021 JBoss by Red Hat. All rights reserved.