Package com.intellij.openapi.application.impl

Class NonBlockingReadActionImpl<T>

java.lang.Object

<any>

com.intellij.openapi.application.impl.NonBlockingReadActionImpl<T>

All Implemented Interfaces:

NonBlockingReadAction<T>

public class NonBlockingReadActionImpl<T>
extends <any>
implements NonBlockingReadAction<T>

Method Summary

Modifier and Type	Method and Description
protected NonBlockingReadActionImpl<T>	cloneWith(ContextConstraint [] constraints, java.util.function.BooleanSupplier [] cancellationConditions, java.util.Set<? extends Expiration> expirationSet)
NonBlockingReadAction<T>	coalesceBy(java.lang.Object... equality) Merges together similar computations by cancelling the previous ones when a new one is submitted.
void	dispatchLaterUnconstrained(java.lang.Runnable runnable)
T	executeSynchronously() Run this computation on the current thread in a non-blocking read action, when possible.
NonBlockingReadAction<T>	expireWhen(java.util.function.BooleanSupplier expireCondition) Returns a copy of this builder that cancels submitted read actions after they become obsolete.
NonBlockingReadActionImpl<T>	expireWith(Disposable parentDisposable)
NonBlockingReadAction<T>	finishOnUiThread(ModalityState modality, java.util.function.Consumer<T> uiThreadAction)
NonBlockingReadAction<T>	inSmartMode(Project project)
CancellablePromise<T>	submit(java.util.concurrent.Executor backgroundThreadExecutor) Submit this computation to be performed in a non-blocking read action on background thread.
static void	waitForAsyncTaskCompletion()
NonBlockingReadAction<T>	withDocumentsCommitted(Project project)
NonBlockingReadAction<T>	wrapProgress(ProgressIndicator progressIndicator)

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.intellij.openapi.application.NonBlockingReadAction

cancelWith

Method Detail

cloneWith

protected NonBlockingReadActionImpl<T> cloneWith(ContextConstraint [] constraints,
                                                 java.util.function.BooleanSupplier [] cancellationConditions,
                                                 java.util.Set<? extends Expiration> expirationSet)

dispatchLaterUnconstrained

public void dispatchLaterUnconstrained(java.lang.Runnable runnable)

inSmartMode

public NonBlockingReadAction<T> inSmartMode(Project project)

Specified by:

inSmartMode in interface NonBlockingReadAction<T>

Returns:

a copy of this builder that runs read actions only when index is available in the given project. The operation is canceled if the project is closed before either the background computation or NonBlockingReadAction.finishOnUiThread(com.intellij.openapi.application.ModalityState, java.util.function.Consumer<T>) runnable are completed.

See Also:

DumbService

withDocumentsCommitted

public NonBlockingReadAction<T> withDocumentsCommitted(Project project)

Specified by:

withDocumentsCommitted in interface NonBlockingReadAction<T>

Returns:

a copy of this builder that runs read actions only when all documents are committed. The operation is canceled if the project is closed before either the background computation or NonBlockingReadAction.finishOnUiThread(com.intellij.openapi.application.ModalityState, java.util.function.Consumer<T>) runnable are completed.

See Also:

PsiDocumentManager

expireWhen

public NonBlockingReadAction<T> expireWhen(java.util.function.BooleanSupplier expireCondition)

Description copied from interface: NonBlockingReadAction

Returns a copy of this builder that cancels submitted read actions after they become obsolete. An action is considered obsolete if any of the conditions provided using expireWhen returns true).

The conditions are checked when read access is allowed, before the computation on a background thread and before NonBlockingReadAction.finishOnUiThread(com.intellij.openapi.application.ModalityState, java.util.function.Consumer<T>) handler, if any.

Even if the expiration condition becomes true without a write action during the background computation, it won't be checked until the computation is complete. Hence if you want to cancel the computation immediately, you should handle that separately (e.g. by putting CancellablePromise.cancel() inside some listener).

Specified by:

expireWhen in interface NonBlockingReadAction<T>

expireWith

public NonBlockingReadActionImpl<T> expireWith(Disposable parentDisposable)

Specified by:

expireWith in interface NonBlockingReadAction<T>

Returns:

a copy of this builder that cancels submitted read actions once the specified disposable is disposed. In that case the corresponding CancellablePromise will be canceled immediately, its completion handlers will be called. Currently running background computations will throw a ProcessCanceledException on the next checkCanceled call, and if computations or NonBlockingReadAction.finishOnUiThread(com.intellij.openapi.application.ModalityState, java.util.function.Consumer<T>) handlers are scheduled, they won't be executed.

wrapProgress

public NonBlockingReadAction<T> wrapProgress(ProgressIndicator progressIndicator)

Specified by:

wrapProgress in interface NonBlockingReadAction<T>

Returns:

a copy of this builder that synchronizes the specified progress indicator with the inner one created by NonBlockingReadAction. This means that submitted read actions are cancelled once the outer indicator is cancelled, and the visual changes (e.g. ProgressIndicator.setText(java.lang.String)) are propagated from the inner to the outer indicator.

finishOnUiThread

public NonBlockingReadAction<T> finishOnUiThread(ModalityState modality,
                                                 java.util.function.Consumer<T> uiThreadAction)

Specified by:

finishOnUiThread in interface NonBlockingReadAction<T>

Returns:

a copy of this builder that completes submitted read actions on UI thread with the given modality state. The read actions are still executed on background thread, but the callbacks on their completion are invoked on UI thread, and no write action is allowed to interfere before that and possibly invalidate the result.

coalesceBy

public NonBlockingReadAction<T> coalesceBy(java.lang.Object... equality)

Description copied from interface: NonBlockingReadAction

Merges together similar computations by cancelling the previous ones when a new one is submitted. This can be useful when the results of the previous computation won't make sense anyway in the changed environment.

Specified by:

coalesceBy in interface NonBlockingReadAction<T>

Parameters:

equality - objects that together identify the computation: if they're all equal in two submissions, then the computations are merged. Callers should take care to pass something unique there (e.g. some Key or this getClass()), so that computations from different places won't interfere.

Returns:

a copy of this builder which, when submitted, cancels previously submitted running computations with equal equality objects

executeSynchronously

public T executeSynchronously()
                       throws ProcessCanceledException

Description copied from interface: NonBlockingReadAction

Run this computation on the current thread in a non-blocking read action, when possible. Note: this method can throw various exceptions (see "Throws" section) and can block the current thread for an indefinite amount of time with just waiting, which can lead to thread starvation or unnecessary thread pool expansion. Besides that, after a read action is finished, a write action in another thread can occur at any time and make the just computed value obsolete. Therefore, it's advised to use asynchronous NonBlockingReadAction.submit(java.util.concurrent.Executor) API where possible, preferably coupled with NonBlockingReadAction.finishOnUiThread(com.intellij.openapi.application.ModalityState, java.util.function.Consumer<T>) to ensure result validity.

If the current thread already has read access, the computation is executed as is, without any write-action-cancellability. It's the responsibility of the caller to take care about it.

NonBlockingReadAction.finishOnUiThread(com.intellij.openapi.application.ModalityState, java.util.function.Consumer<T>) and NonBlockingReadAction.coalesceBy(java.lang.Object...) are not supported with synchronous non-blocking read actions.

Specified by:

executeSynchronously in interface NonBlockingReadAction<T>

Returns:

the result of the computation

Throws:

ProcessCanceledException - if the computation got expired due to NonBlockingReadAction.expireWhen(java.util.function.BooleanSupplier) or NonBlockingReadAction.expireWith(com.intellij.openapi.Disposable) or NonBlockingReadAction.wrapProgress(com.intellij.openapi.progress.ProgressIndicator).

submit

public CancellablePromise<T> submit(java.util.concurrent.Executor backgroundThreadExecutor)

Description copied from interface: NonBlockingReadAction

Submit this computation to be performed in a non-blocking read action on background thread. The returned promise is completed on the same thread (in the same read action), or on UI thread if NonBlockingReadAction.finishOnUiThread(com.intellij.openapi.application.ModalityState, java.util.function.Consumer<T>) has been called.

Specified by:

submit in interface NonBlockingReadAction<T>

Parameters:

backgroundThreadExecutor - an executor to actually run the computation. Common examples are com.intellij.util.concurrency.NonUrgentExecutor#getInstance() or AppExecutorUtil.getAppExecutorService() or BoundedTaskExecutor on top of that.

waitForAsyncTaskCompletion

public static void waitForAsyncTaskCompletion()