Module org.scijava.concurrent

Package org.scijava.concurrent

Class Parallelization

java.lang.Object

org.scijava.concurrent.Parallelization

public final class Parallelization
extends Object

This class allows to configure an algorithm for parallelization.

The algorithm needs to use the TaskExecutor returned by getTaskExecutor() to implement the parallelization. Alternatively it can use getExecutorService(). But TaskExecutor is simpler and better suited for image processing algorithms.

The algorithm can be executed singleThreaded, multiThreaded or by using a specified ExecutorService or TaskExecutor:

     

     // Single-threaded call
     Parallelization.runSingleThreaded( () -> myAlgorithm( image ) );

     // Multi-threaded call
     Parallelization.runMultiThreaded( () -> myAlgorithm( image ) );

     // ExecutorService
     Parallelization.withExecutor( executorService, () -> myAlgorithm( image ) );

     // Multi-threaded is the default.
     //     A normal function call, that's not somehow wrapped by
     //     Parallelization.runSingleThreaded( ... ) runs multi-threaded.
     myAlgorithm( image );

     // Example Algorithm, that fills an image with ones.
     public void myAlgorithm( RandomAccessibleInterval< IntType > image )
     {
         TaskExecutor taskExecutor = Parallelization.getTaskExecutor();
         int numTasks = taskExecutor.suggestNumberOfTasks();
         List< Interval > chunks = IntervalChunks.chunkInterval( image, numTasks );

         // The TaskExecutor executes the forEach method in multiple threads, if requested.
         taskExecutor.forEach( chunks, chunk -> {
             for ( IntType pixel : Views.interval( image, chunk ) )
                 pixel.setOne();
         } );
     }
     
 

Method Summary

Modifier and Type	Method	Description
static ExecutorService	getExecutorService()
static TaskExecutor	getTaskExecutor()	Returns the TaskExecutor that was set for this thread.
static void	runMultiThreaded(Runnable action)	To run an algorithm multi-threaded use:
static <T> T	runMultiThreaded(Callable<T> action)	To run an algorithm multi-threaded use:
static void	runSingleThreaded(Runnable action)	To run an algorithm single-threaded use:
static <T> T	runSingleThreaded(Callable<T> action)	To run an algorithm single-threaded use:
static void	runWithExecutor(ExecutorService executorService, Runnable action)	Executes the given Runnable with the given ExecutorService, and waits for the execution to finish.
static <R> R	runWithExecutor(ExecutorService executorService, Callable<R> action)	Executes the given Callable with the given ExecutorService, waits for the execution to finish and returns the result.
static void	runWithExecutor(TaskExecutor taskExecutor, Runnable action)	Executes the given Runnable with the given TaskExecutor, and waits for the execution to finish.
static <T> T	runWithExecutor(TaskExecutor taskExecutor, Callable<T> action)	Executes the given Callable with the given TaskExecutor, waits for the execution to finish and returns the result.
static void	runWithNumThreads(int numThreads, Runnable action)	To run an algorithm a given number of threads use:
static <R> R	runWithNumThreads(int numThreads, Callable<R> action)	To run an algorithm a given number of threads use:

Methods inherited from class java.lang.Object

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

Method Detail

getTaskExecutor

public static TaskExecutor getTaskExecutor()

Returns the TaskExecutor that was set for this thread.

getExecutorService

public static ExecutorService getExecutorService()

runSingleThreaded

public static void runSingleThreaded(Runnable action)

To run an algorithm single-threaded use:

Parallelization.runSingleThreaded( () -> myAlgorithm( input ) );

runSingleThreaded

public static <T> T runSingleThreaded(Callable<T> action)

To run an algorithm single-threaded use:

output = Parallelization.runSingleThreaded( () -> myAlgorithm( input ) );

runMultiThreaded

public static void runMultiThreaded(Runnable action)

To run an algorithm multi-threaded use:

Parallelization.runMultiThreaded( () -> myAlgorithm( input ) );

runMultiThreaded

public static <T> T runMultiThreaded(Callable<T> action)

To run an algorithm multi-threaded use:

output = Parallelization.runMultiThreaded( () -> myAlgorithm( input ) );

runWithNumThreads

public static void runWithNumThreads(int numThreads,
                                     Runnable action)

To run an algorithm a given number of threads use:

Parallelization.runWithNumThreads( numThreads, () -> myAlgorithm( input ) );

runWithNumThreads

public static <R> R runWithNumThreads(int numThreads,
                                      Callable<R> action)

To run an algorithm a given number of threads use:

output = Parallelization.runWithNumThreads( numThreads, () -> myAlgorithm( input ) );

runWithExecutor

public static void runWithExecutor(ExecutorService executorService,
                                   Runnable action)

Executes the given Runnable with the given ExecutorService, and waits for the execution to finish.

runWithExecutor

public static <R> R runWithExecutor(ExecutorService executorService,
                                    Callable<R> action)

Executes the given Callable with the given ExecutorService, waits for the execution to finish and returns the result.

runWithExecutor

public static void runWithExecutor(TaskExecutor taskExecutor,
                                   Runnable action)

Executes the given Runnable with the given TaskExecutor, and waits for the execution to finish.

runWithExecutor

public static <T> T runWithExecutor(TaskExecutor taskExecutor,
                                    Callable<T> action)

Executes the given Callable with the given TaskExecutor, waits for the execution to finish and returns the result.