TransactionRunner (Oracle - Berkeley DB Java API)
Date: 2020-06-01

Package com.sleepycat.collections

## Class TransactionRunner

- java.lang.Object
- - com.sleepycat.collections.TransactionRunner

-     public class TransactionRunner
      extends java.lang.Object

  Starts a transaction, calls `TransactionWorker.doWork()`, and handles transaction retry and exceptions. To perform a transaction, the user implements the `TransactionWorker` interface and passes an instance of that class to the `run` method.

  A single TransactionRunner instance may be used by any number of threads for any number of transactions.

  The behavior of the run() method depends on whether the environment is transactional, whether nested transactions are enabled, and whether a transaction is already active.

  - When the run() method is called in a transactional environment and no transaction is active for the current thread, a new transaction is started before calling doWork(). If DeadlockException is thrown by doWork(), the transaction will be aborted and the process will be repeated up to the maximum number of retries. If another exception is thrown by doWork() or the maximum number of retries has occurred, the transaction will be aborted and the exception will be rethrown by the run() method. If no exception is thrown by doWork(), the transaction will be committed. The run() method will not attempt to commit or abort a transaction if it has already been committed or aborted by doWork().
  - When the run() method is called and a transaction is active for the current thread, and nested transactions are enabled, a nested transaction is started before calling doWork(). The transaction that is active when calling the run() method will become the parent of the nested transaction. The nested transaction will be committed or aborted by the run() method following the same rules described above. Note that nested transactions may not be enabled for the JE product, since JE does not support nested transactions.
  - When the run() method is called in a non-transactional environment, the doWork() method is called without starting a transaction. The run() method will return without committing or aborting a transaction, and any exceptions thrown by the doWork() method will be thrown by the run() method.
  - When the run() method is called and a transaction is active for the current thread and nested transactions are not enabled (the default) the same rules as above apply. All the operations performed by the doWork() method will be part of the currently active transaction.

  In a transactional environment, the rules described above support nested calls to the run() method and guarantee that the outermost call will cause the transaction to be committed or aborted. This is true whether or not nested transactions are supported or enabled. Note that nested transactions are provided as an optimization for improving concurrency but do not change the meaning of the outermost transaction. Nested transactions are not currently supported by the JE product.

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static int` | `DEFAULT_MAX_RETRIES` | The default maximum number of retries.

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `TransactionRunner​(Environment env)` | Creates a transaction runner for a given Berkeley DB environment.
    `TransactionRunner​(Environment env, int maxRetries, TransactionConfig config)` | Creates a transaction runner for a given Berkeley DB environment and with a given number of maximum retries.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `boolean` | `getAllowNestedTransactions()` | Returns whether nested transactions will be created if `run()` is called when a transaction is already active for the current thread.
    `int` | `getMaxRetries()` | Returns the maximum number of retries that will be performed when deadlocks are detected.
    `TransactionConfig` | `getTransactionConfig()` | Returns the transaction configuration used for calling `Environment.beginTransaction(com.sleepycat.db.Transaction, com.sleepycat.db.TransactionConfig)`.
    `int` | `handleException​(java.lang.Exception exception, int retries, int maxRetries)` | Handles exceptions that occur during a transaction, and may implement transaction retry policy.
    `void` | `run​(TransactionWorker worker)` | Calls the `TransactionWorker.doWork()` method and, for transactional environments, may begin and end a transaction.
    `void` | `setAllowNestedTransactions​(boolean allowNestedTxn)` | Changes whether nested transactions will be created if `run()` is called when a transaction is already active for the current thread.
    `void` | `setMaxRetries​(int maxRetries)` | Changes the maximum number of retries that will be performed when deadlocks are detected.
    `void` | `setTransactionConfig​(TransactionConfig config)` | Changes the transaction configuration used for calling `Environment.beginTransaction(com.sleepycat.db.Transaction, com.sleepycat.db.TransactionConfig)`.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### DEFAULT_MAX_RETRIES

          public static final int DEFAULT_MAX_RETRIES

      The default maximum number of retries.
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### TransactionRunner

          public TransactionRunner​(Environment env)

      Creates a transaction runner for a given Berkeley DB environment. The default maximum number of retries (`DEFAULT_MAX_RETRIES`) and a null (default) `TransactionConfig` will be used.
      Parameters:
        `env` - is the environment for running transactions.

    - #### TransactionRunner

          public TransactionRunner​(Environment env,
                                   int maxRetries,
                                   TransactionConfig config)

      Creates a transaction runner for a given Berkeley DB environment and with a given number of maximum retries.
      Parameters:
        `env` - is the environment for running transactions.
        `maxRetries` - is the maximum number of retries that will be performed when deadlocks are detected.
        `config` - the transaction configuration used for calling `Environment.beginTransaction(com.sleepycat.db.Transaction, com.sleepycat.db.TransactionConfig)`, or null to use the default configuration. The configuration object is not cloned, and any modifications to it will impact subsequent transactions.

  - ### Method Detail

    - #### getMaxRetries

          public int getMaxRetries()

      Returns the maximum number of retries that will be performed when deadlocks are detected.
      Returns:
        the maximum number of retries.

    - #### setMaxRetries

          public void setMaxRetries​(int maxRetries)

      Changes the maximum number of retries that will be performed when deadlocks are detected. Calling this method does not impact transactions already running.
      Parameters:
        `maxRetries` - the maximum number of retries.

    - #### getAllowNestedTransactions

          public boolean getAllowNestedTransactions()

      Returns whether nested transactions will be created if `run()` is called when a transaction is already active for the current thread. By default this property is false.
      Returns:
        whether nested transactions will be created.

        Note that this method always returns false in the JE product, since nested transactions are not supported by JE.

    - #### setAllowNestedTransactions

          public void setAllowNestedTransactions​(boolean allowNestedTxn)

      Changes whether nested transactions will be created if `run()` is called when a transaction is already active for the current thread. Calling this method does not impact transactions already running.
      Parameters:
        `allowNestedTxn` - whether nested transactions will be created.

        Note that true may not be passed to this method in the JE product, since nested transactions are not supported by JE.

    - #### getTransactionConfig

          public TransactionConfig getTransactionConfig()

      Returns the transaction configuration used for calling `Environment.beginTransaction(com.sleepycat.db.Transaction, com.sleepycat.db.TransactionConfig)`.

      If this property is null, the default configuration is used. The configuration object is not cloned, and any modifications to it will impact subsequent transactions.

      Returns:
        the transaction configuration.

    - #### setTransactionConfig

          public void setTransactionConfig​(TransactionConfig config)

      Changes the transaction configuration used for calling `Environment.beginTransaction(com.sleepycat.db.Transaction, com.sleepycat.db.TransactionConfig)`.

      If this property is null, the default configuration is used. The configuration object is not cloned, and any modifications to it will impact subsequent transactions.

      Parameters:
        `config` - the transaction configuration.

    - #### run

          public void run​(TransactionWorker worker)
                   throws DatabaseException,
                          java.lang.Exception

      Calls the `TransactionWorker.doWork()` method and, for transactional environments, may begin and end a transaction. If the environment given is non-transactional, a transaction will not be used but the doWork() method will still be called. See the class description for more information.
      Parameters:
        `worker` - the TransactionWorker.
      Throws:
        `DeadlockException` - when it is thrown by doWork() and the maximum number of retries has occurred. The transaction will have been aborted by this method.
        `java.lang.Exception` - when any other exception is thrown by doWork(). The exception will first be unwrapped by calling `ExceptionUnwrapper.unwrap(java.lang.Exception)`. The transaction will have been aborted by this method.
        `DatabaseException`

    - #### handleException

          public int handleException​(java.lang.Exception exception,
                                     int retries,
                                     int maxRetries)
                              throws java.lang.Exception

      Handles exceptions that occur during a transaction, and may implement transaction retry policy. The transaction is aborted by the `run` method before calling this method.

      The default implementation of this method throws the `exception` parameter if it is not an instance of `DeadlockException` and otherwise returns the `maxRetries` parameter value. This method can be overridden to throw a different exception or return a different number of retries. For example:

      - This method could call `Thread.sleep` for a short interval to allow other transactions to finish.
      - This method could return a different `maxRetries` value depending on the `exception` that occurred.
      - This method could throw an application-defined exception when the `retries` value is greater or equal to the `maxRetries` and a `DeadlockException` occurs, to override the default behavior which is to throw the `DeadlockException`.
      Parameters:
        `exception` - an exception that was thrown by the `TransactionWorker.doWork()` method or thrown when beginning or committing the transaction. If the `retries` value is greater or equal to `maxRetries` when this method returns normally, this exception will be thrown by the `run` method.
        `retries` - the current value of a counter that starts out at zero and is incremented when each retry is performed.
        `maxRetries` - the maximum retries to be performed. By default, this value is set to `getMaxRetries()`. This method may return a different maximum retries value to override that default.
      Returns:
        the maximum number of retries to perform. The default policy is to return the `maxRetries` parameter value if the `exception` parameter value is an instance of `DeadlockException`.
      Throws:
        `java.lang.Exception` - to cause the exception to be thrown by the `run` method. The default policy is to throw the `exception` parameter value if it is not an instance of `DeadlockException`.
      Since:
        3.4

Copyright (c) 1996, 2020 Oracle and/or its affiliates. All rights reserved.