Class TransactionalLock

  • All Implemented Interfaces:
    Transactional
    Direct Known Subclasses:
    TxnDataset2Graph

    public class TransactionalLock
    extends java.lang.Object
    implements Transactional
    An implementation of Transactional that provides MRSW locking but no abort. This is often the best you can do for a system that does not itself provide transactions.
    API Note:
    To use with implementation inheritance, for when you don't inherit:
          private final Transactional txn                     = TransactionalLock.createMRSW() ;
          private final Transactional txn()                   { return txn; }
          @Override public void begin(TxnType txnType)        { txn().begin(txnType) ; }
          @Override public void begin()                       { txn().begin(); }
          @Override public void begin(TxnType txnType)        { txn().begin(txnType); }
          @Override public void begin(ReadWrite mode)         { txn().begin(mode); }
          @Override public boolean promote()                  { return txn().promote(); }
          @Override public void commit()                      { txn().commit(); }
          @Override public void abort()                       { txn().abort(); }
          @Override public boolean isInTransaction()          { return txn().isInTransaction(); }
          @Override public void end()                         { txn().end(); }
          @Override public ReadWrite transactionMode()        { return txn().transactionMode(); }
          @Override public TxnType transactionType()          { return txn().transactionType(); }
          @Override public boolean supportsTransactions()     { return true; }
          @Override public boolean supportsTransactionAbort() { return false; }
       
    • Method Detail

      • create

        public static TransactionalLock create​(Lock lock)
        Create a Transactional using the given lock
      • createMRPlusSW

        public static TransactionalLock createMRPlusSW()
        Create a Transactional using a MR+SW (Multiple Reader AND a Single Writer) lock
      • createMRSW

        public static TransactionalLock createMRSW()
        Create a Transactional using a MRSW (Multiple Reader OR a Single Writer) lock
      • createMutex

        public static TransactionalLock createMutex()
        Create a Transactional using a mutex (exclusive - one at a time) lock
      • begin

        public void begin​(TxnType txnType)
        Description copied from interface: Transactional
        Start a transaction.
        READ or WRITE transactions start in that state and do not change for the lifetime of the transaction.
        • WRITE: this guarantees a WRITE will complete if commit() is called. The same as begin(ReadWrite.WRITE).
        • READ: the transaction can not promote to WRITE,ensuring read-only access to the data. The same as begin(ReadWrite.READ).
        • READ_PROMOTE: the transaction will go from "read" to "write" if an update is attempted and if the dataset has not been changed by another write transaction. See also Transactional.promote().
        • READ_COMMITTED_PROMOTE: Use this with care. The promotion will succeed but changes from other transactions become visible.
        Read committed: at the point transaction attempts promotion from "read" to "write", the system checks if the dataset has change since the transaction started (called begin). If READ_PROMOTE, the dataset must not have changed; if READ_COMMITTED_PROMOTE any intermediate changes are visible but the application can not assume any data it has read in the transaction is the same as it was at the point the transaction started.

        This operation is optional and some implementations may throw a JenaTransactionException exception for some or all TxnType values.

        See Transactional.begin(ReadWrite) for a form that is required of implementations.

        Specified by:
        begin in interface Transactional
      • transactionMode

        public ReadWrite transactionMode()
        Description copied from interface: Transactional
        Return the current mode of the transaction - "read" or "write". If the caller is not in a transaction, this method returns null.
        Specified by:
        transactionMode in interface Transactional
      • transactionType

        public TxnType transactionType()
        Description copied from interface: Transactional
        Return the transaction type used in begin(TxnType). If the caller is not in a transaction, this method returns null.
        Specified by:
        transactionType in interface Transactional
      • promote

        public boolean promote​(Transactional.Promote txnType)
        Description copied from interface: Transactional
        Attempt to promote a transaction from "read" mode to "write" and the transaction. This method allows the form of promotion to be specified. The transaction must not have been started with READ, which is read-only.

        An argument of READ_PROMOTE treats the promotion as if the transaction was started with READ_PROMOTE (any other writer commiting since the transaction started blocks promotion) and READ_COMMITTED_PROMOTE treats the promotion as if the transaction was started with READ_COMMITTED_PROMOTE (intemediate writer commits become visible).

        Returns "true" if the transaction is in write mode after the call. The method always succeeds of the transaction is already "write".

        This method returns true if a READ_PROMOTE or READ_COMMITTED_PROMOTE is promoted.

        This method returns false if a READ_PROMOTE can't be promoted - the transaction is still valid and in "read" mode.

        This method throws an exception if there is an attempt to promote a READ transaction.

        Specified by:
        promote in interface Transactional
      • commit

        public void commit()
        Description copied from interface: Transactional
        Commit a transaction - finish the transaction and make any changes permanent (if a "write" transaction)
        Specified by:
        commit in interface Transactional
      • abort

        public void abort()
        Description copied from interface: Transactional
        Abort a transaction - finish the transaction and undo any changes (if a "write" transaction)
        Specified by:
        abort in interface Transactional
      • isTransactionMode

        public boolean isTransactionMode​(ReadWrite mode)
      • end

        public void end()
        Description copied from interface: Transactional
        Finish the transaction - if a write transaction and commit() has not been called, then abort
        Specified by:
        end in interface Transactional