Package com.intellij.concurrency

Class JobLauncher

java.lang.Object

com.intellij.concurrency.JobLauncher

Direct Known Subclasses:

JobLauncherImpl

public abstract class JobLauncher
extends java.lang.Object

Invitation-only service for running short-lived computing-intensive IO-free tasks on all available CPU cores. DO NOT USE for your tasks, IO-bound or long tasks, there are Application.executeOnPooledThread(java.lang.Runnable), ProcessIOExecutorService and com.intellij.util.concurrency.NonUrgentExecutor for that.

Constructor Summary

Constructors

Constructor and Description
JobLauncher()

Method Summary

Modifier and Type	Method and Description
static JobLauncher	getInstance()
abstract <T> boolean	invokeConcurrentlyUnderProgress(java.util.List<? extends T> things, ProgressIndicator progress, boolean runInReadAction, boolean failFastOnAcquireReadAction, Processor<? super T> thingProcessor)
<T> boolean	invokeConcurrentlyUnderProgress(java.util.List<? extends T> things, ProgressIndicator progress, boolean failFastOnAcquireReadAction, Processor<? super T> thingProcessor) Deprecated. use invokeConcurrentlyUnderProgress(List, ProgressIndicator, Processor) instead
<T> boolean	invokeConcurrentlyUnderProgress(java.util.List<? extends T> things, ProgressIndicator progress, Processor<? super T> thingProcessor) Schedules concurrent execution of thingProcessor over each element of things and waits for completion with checkCanceled in each thread delegated to the progress (or the current global progress if null).
abstract Job<java.lang.Void>	submitToJobThread(java.lang.Runnable action, Consumer<? super java.util.concurrent.Future<?>> onDoneCallback) NEVER EVER submit runnable which can lock itself for indeterminate amount of time.

Methods inherited from class java.lang.Object

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

Constructor Detail

JobLauncher

public JobLauncher()

Method Detail

getInstance

public static JobLauncher getInstance()

invokeConcurrentlyUnderProgress

public <T> boolean invokeConcurrentlyUnderProgress(java.util.List<? extends T> things,
                                                   ProgressIndicator progress,
                                                   Processor<? super T> thingProcessor)
                                            throws ProcessCanceledException

Schedules concurrent execution of thingProcessor over each element of things and waits for completion with checkCanceled in each thread delegated to the progress (or the current global progress if null). Note: When the thingProcessor throws an exception or returns false or the current indicator is canceled, the method is finished with false as soon as possible, which means some workers might still be in flight to completion. On the other hand, when the method returns true, it's guaranteed that the whole list was processed and all tasks completed.

Parameters:

things - data to process concurrently

progress - progress indicator

thingProcessor - to be invoked concurrently on each element from the collection

Returns:

false if tasks have been canceled, or at least one processor returned false, or threw an exception, or we were unable to start read action in at least one thread

Throws:

ProcessCanceledException - if at least one task has thrown ProcessCanceledException

invokeConcurrentlyUnderProgress

@Deprecated
public <T> boolean invokeConcurrentlyUnderProgress(java.util.List<? extends T> things,
                                                   ProgressIndicator progress,
                                                   boolean failFastOnAcquireReadAction,
                                                   Processor<? super T> thingProcessor)
                                            throws ProcessCanceledException

Deprecated. use invokeConcurrentlyUnderProgress(List, ProgressIndicator, Processor) instead

Schedules concurrent execution of #thingProcessor over each element of #things and waits for completion With checkCanceled in each thread delegated to our current progress

Parameters:

things - data to process concurrently

progress - progress indicator

failFastOnAcquireReadAction - if true, returns false when failed to acquire read action

thingProcessor - to be invoked concurrently on each element from the collection

Returns:

false if tasks have been canceled, or at least one processor returned false, or threw an exception, or we were unable to start read action in at least one thread

Throws:

ProcessCanceledException - if at least one task has thrown ProcessCanceledException

invokeConcurrentlyUnderProgress

public abstract <T> boolean invokeConcurrentlyUnderProgress(java.util.List<? extends T> things,
                                                            ProgressIndicator progress,
                                                            boolean runInReadAction,
                                                            boolean failFastOnAcquireReadAction,
                                                            Processor<? super T> thingProcessor)
                                                     throws ProcessCanceledException

Throws:

ProcessCanceledException

submitToJobThread

public abstract Job<java.lang.Void> submitToJobThread(java.lang.Runnable action,
                                                      Consumer<? super java.util.concurrent.Future<?>> onDoneCallback)

NEVER EVER submit runnable which can lock itself for indeterminate amount of time. This will cause deadlock since this thread pool is an easily exhaustible resource. Use Application.executeOnPooledThread(Runnable) instead