Package com.zfabrik.util.threading

## Class ThreadUtil

- java.lang.Object
- - com.zfabrik.util.threading.ThreadUtil

-     public class ThreadUtil
      extends java.lang.Object

  Threading utils. Not thread pools and such but rather utilities that help isolating resources and avoiding memory leaks.
  Author:
    hb

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `ThreadUtil()` |

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <T> T` | `cleanContextExceptionExecute​(java.lang.ClassLoader contextLoader, java.util.concurrent.Callable<T> callable)` | Stupid...
    `static <T> T` | `cleanContextExceptionExecute​(java.util.concurrent.Callable<T> callable)` | Short version of `cleanContextExceptionExecute(ClassLoader, Callable)` passing in `null` as context class loader.
    `static <T> T` | `cleanContextExecute​(java.lang.ClassLoader contextLoader, java.util.concurrent.Callable<T> callable)` | Execute a callable with a clean thread context and security context as to avoid any passing on of thread context and security context to another thread that may be spawned from here and may end up holding copies in the end.
    `static <T> T` | `cleanContextExecute​(java.util.concurrent.Callable<T> callable)` | Short version of `cleanContextExecute(ClassLoader, Callable)` passing in `null` as context class loader.
    `static <T,​E extends java.lang.Exception> T` | `cleanContextGet​(ThrowingSupplier<T,​E> supplier)` | Variation of `cleanContextExceptionExecute(Callable)` that relies on `ThrowingSupplier` to generically limit the amount of noise due to missing exception interference.
    `static <T,​E extends java.lang.Exception> T` | `cleanContextGet​(java.lang.ClassLoader contextLoader, ThrowingSupplier<T,​E> supplier)` | Variation of `cleanContextExceptionExecute(ClassLoader, Callable)` that relies on `ThrowingSupplier` to generically limit the amount of noise due to missing exception interference.
    `static <E extends java.lang.Exception> void` | `cleanContextRun​(ThrowingRunnable<E> run)` | Short version of `#cleanContextRun(ClassLoader, Runnable)` passing in `null` as context class loader.
    `static <E extends java.lang.Exception> void` | `cleanContextRun​(java.lang.ClassLoader contextLoader, ThrowingRunnable<E> run)` | Execute a `ThrowingRunnable` with a clean thread context and security context as to avoid any passing on of thread context and security context to another thread that may be spawned from here and may end up holding copies in the end.
    `static <T> T` | `cleanContextSupply​(java.lang.ClassLoader contextLoader, java.util.function.Supplier<T> supplier)` | Execute a `Supplier` with a clean thread context and security context as to avoid any passing on of thread context and security context to another thread that may be spawned from here and may end up holding copies in the end.
    `static <T> T` | `cleanContextSupply​(java.util.function.Supplier<T> supplier)` | Short version of `cleanContextSupply(ClassLoader, Supplier)` passing in `null` as context class loader.
    `static <T,​E extends java.lang.Exception> T` | `confine​(java.util.concurrent.Callable<T> call, java.lang.Class<E> eclz)` | Using this method, an invocation of a callable may be wrapped to only throw a declared checked exception.

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

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

- - ### Constructor Detail

    - #### ThreadUtil

          public ThreadUtil()

  - ### Method Detail

    - #### cleanContextExceptionExecute

          public static <T> T cleanContextExceptionExecute​(java.lang.ClassLoader contextLoader,
                                                           java.util.concurrent.Callable<T> callable)
                                                    throws java.lang.Exception

      Stupid... but there is places all over that hold on to AccessControlContexts and Context Class Loaders. This easily consitutes a leak. So, for stuff that doesn't need anything from the context class loader this is a way of keeping context to a minimum;

      Execute a callable with a clean thread context and security context as to avoid any passing on of thread context and security context to another thread that may be spawned from here and may end up holding copies in the end. Any exception thrown will be propagated.

      See also `confine(Callable, Class)`.

      Parameters:
        `contextLoader` - A class loader to set as context class loader
        `callable` - A `Callable` to invoke
      Returns:
        Return value from the `Callable` invocation
      Throws:
        `java.lang.Exception`

    - #### cleanContextExceptionExecute

          public static <T> T cleanContextExceptionExecute​(java.util.concurrent.Callable<T> callable)
                                                    throws java.lang.Exception

      Short version of `cleanContextExceptionExecute(ClassLoader, Callable)` passing in `null` as context class loader.
      Parameters:
        `callable` - A `Callable` to invoke
      Returns:
        Return value from the `Callable` invocation
      Throws:
        `java.lang.Exception`

    - #### cleanContextExecute

          public static <T> T cleanContextExecute​(java.lang.ClassLoader contextLoader,
                                                  java.util.concurrent.Callable<T> callable)

      Execute a callable with a clean thread context and security context as to avoid any passing on of thread context and security context to another thread that may be spawned from here and may end up holding copies in the end. Any exception caught will be wrapped in a generic runtime exception.
      Parameters:
        `contextLoader` - A class loader to set as context class loader
        `callable` - A `Callable` to invoke
      Returns:
        Return value from the `Callable` invocation

    - #### cleanContextExecute

          public static <T> T cleanContextExecute​(java.util.concurrent.Callable<T> callable)

      Short version of `cleanContextExecute(ClassLoader, Callable)` passing in `null` as context class loader.
      Parameters:
        `callable` - A `Callable` to invoke
      Returns:
        Return value from the `Callable` invocation

    - #### cleanContextSupply

          public static <T> T cleanContextSupply​(java.lang.ClassLoader contextLoader,
                                                 java.util.function.Supplier<T> supplier)

      Execute a `Supplier` with a clean thread context and security context as to avoid any passing on of thread context and security context to another thread that may be spawned from here and may end up holding copies in the end.
      Parameters:
        `contextLoader` - A class loader to set as context class loader
        `supplier` - A `Supplier` to invoke
      Returns:
        Return value from the `Supplier` invocation

    - #### cleanContextSupply

          public static <T> T cleanContextSupply​(java.util.function.Supplier<T> supplier)

      Short version of `cleanContextSupply(ClassLoader, Supplier)` passing in `null` as context class loader.
      Parameters:
        `supplier` - A `Supplier` to invoke
      Returns:
        Return value from the `Supplier` invocation

    - #### confine

          public static <T,​E extends java.lang.Exception> T confine​(java.util.concurrent.Callable<T> call,
                                                                          java.lang.Class<E> eclz)
                                                                   throws E extends java.lang.Exception

      Using this method, an invocation of a callable may be wrapped to only throw a declared checked exception.

      - If the supplied invocation throws the confinement exception or a sub class, this exception will be rethrown.
      - If the supplied invocation throws the `RuntimeException`, this exception will be rethrown.
      - Any other exception will be wrapped into a `RuntimeException`

      This is handy when it is required to pass a callable given an execution that potentially throws a check exception that is much narrower in scope than simply `Exception`.

      For example given a method `readTable` that throws a `SQLException`, an equivalent execution using `cleanContextExceptionExecute(Callable)` looks like this:

           confine(()->cleanContextExceptionExecute(this::readTable),SQLException.class);

      Parameters:
        `eclz` - the confinement exception
        `call` - the `Callable` to invoke
      Returns:
        the result of the `Callable` invocation
      Throws:
        `E` - A confinement exception
        `E extends java.lang.Exception`

    - #### cleanContextGet

          public static <T,​E extends java.lang.Exception> T cleanContextGet​(java.lang.ClassLoader contextLoader,
                                                                                  ThrowingSupplier<T,​E> supplier)
                                                                           throws E extends java.lang.Exception

      Variation of `cleanContextExceptionExecute(ClassLoader, Callable)` that relies on `ThrowingSupplier` to generically limit the amount of noise due to missing exception interference. In many places using lambdas this approach is syntactically nicer than using confine
      Throws:
        `E extends java.lang.Exception`

    - #### cleanContextGet

          public static <T,​E extends java.lang.Exception> T cleanContextGet​(ThrowingSupplier<T,​E> supplier)
                                                                           throws E extends java.lang.Exception

      Variation of `cleanContextExceptionExecute(Callable)` that relies on `ThrowingSupplier` to generically limit the amount of noise due to missing exception interference. In many places using lambdas this approach is syntactically nicer than using confine
      Throws:
        `E extends java.lang.Exception`

    - #### cleanContextRun

          public static <E extends java.lang.Exception> void cleanContextRun​(java.lang.ClassLoader contextLoader,
                                                                             ThrowingRunnable<E> run)
                                                                      throws E extends java.lang.Exception

      Execute a `ThrowingRunnable` with a clean thread context and security context as to avoid any passing on of thread context and security context to another thread that may be spawned from here and may end up holding copies in the end.
      Parameters:
        `contextLoader` - A class loader to set as context class loader
        `run` - A `Runnable` to invoke
      Throws:
        `E extends java.lang.Exception`

    - #### cleanContextRun

          public static <E extends java.lang.Exception> void cleanContextRun​(ThrowingRunnable<E> run)
                                                                      throws E extends java.lang.Exception

      Short version of `#cleanContextRun(ClassLoader, Runnable)` passing in `null` as context class loader.
      Parameters:
        `run` - A `Runnable` to invoke
      Throws:
        `E extends java.lang.Exception`