Package com.intellij.openapi.progress.util

Class ProgressIndicatorUtils

java.lang.Object

com.intellij.openapi.progress.util.ProgressIndicatorUtils

public class ProgressIndicatorUtils
extends java.lang.Object

Most methods in this class are used to equip long background processes which take read actions with a special listener that fires when a write action is about to begin, and cancels corresponding progress indicators to avoid blocking the UI. These processes should be ready to get ProcessCanceledException at any moment. Processes may want to react on cancellation event by restarting the activity, see ReadTask.onCanceled(ProgressIndicator) for that.

Constructor Summary

Constructors

Constructor and Description
ProgressIndicatorUtils()

Method Summary

Modifier and Type	Method and Description
static void	awaitWithCheckCanceled(java.util.concurrent.CountDownLatch waiter)
static <T> T	awaitWithCheckCanceled(java.util.concurrent.Future<T> future)
static <T> T	awaitWithCheckCanceled(java.util.concurrent.Future<T> future, ProgressIndicator indicator)
static void	awaitWithCheckCanceled(java.util.concurrent.locks.Lock lock, int timeout, java.util.concurrent.TimeUnit timeUnit)
static void	awaitWithCheckCanceled(Semaphore semaphore, ProgressIndicator indicator)
static void	checkCancelledEvenWithPCEDisabled(ProgressIndicator indicator) Use when otherwise a deadlock is possible.
static <T,E extends java.lang.Throwable> T	computeWithLockAndCheckingCanceled(java.util.concurrent.locks.Lock lock, int timeout, java.util.concurrent.TimeUnit timeUnit, ThrowableComputable<T,E> computable)
static ProgressIndicator	forceWriteActionPriority(ProgressIndicator progress, Disposable parentDisposable)
static boolean	runInReadActionWithWriteActionPriority(java.lang.Runnable action) This method attempts to run provided action synchronously in a read action, so that, if possible, it wouldn't impact any pending, executing or future write actions (for this to work effectively the action should invoke ProgressManager.checkCanceled() or ProgressIndicator.checkCanceled() often enough).
static boolean	runInReadActionWithWriteActionPriority(java.lang.Runnable action, ProgressIndicator progressIndicator) Same as runInReadActionWithWriteActionPriority(Runnable), optionally allowing to pass a ProgressIndicator instance, which can be used to cancel action externally.
static boolean	runWithWriteActionPriority(java.lang.Runnable action, ProgressIndicator progressIndicator)
static java.util.concurrent.CompletableFuture<?>	scheduleWithWriteActionPriority(java.util.concurrent.Executor executor, ReadTask task)
static java.util.concurrent.CompletableFuture<?>	scheduleWithWriteActionPriority(ProgressIndicator progressIndicator, java.util.concurrent.Executor executor, ReadTask readTask)
static java.util.concurrent.CompletableFuture<?>	scheduleWithWriteActionPriority(ProgressIndicator progressIndicator, ReadTask readTask)
static void	scheduleWithWriteActionPriority(ReadTask task)
static <T> T	withTimeout(long timeoutMs, Computable<T> computation) Run the given computation with its execution time restricted to the given amount of time in milliseconds.
static void	yieldToPendingWriteActions() Ensure the current EDT activity finishes in case it requires many write actions, with each being delayed a bit by background thread read action (until its first checkCanceled call).

Methods inherited from class java.lang.Object

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

Constructor Detail

ProgressIndicatorUtils

public ProgressIndicatorUtils()

Method Detail

forceWriteActionPriority

public static ProgressIndicator forceWriteActionPriority(ProgressIndicator progress,
                                                         Disposable parentDisposable)

scheduleWithWriteActionPriority

public static void scheduleWithWriteActionPriority(ReadTask task)

scheduleWithWriteActionPriority

public static java.util.concurrent.CompletableFuture<?> scheduleWithWriteActionPriority(ProgressIndicator progressIndicator,
                                                                                        ReadTask readTask)

scheduleWithWriteActionPriority

public static java.util.concurrent.CompletableFuture<?> scheduleWithWriteActionPriority(java.util.concurrent.Executor executor,
                                                                                        ReadTask task)

runInReadActionWithWriteActionPriority

public static boolean runInReadActionWithWriteActionPriority(java.lang.Runnable action,
                                                             ProgressIndicator progressIndicator)

Same as runInReadActionWithWriteActionPriority(Runnable), optionally allowing to pass a ProgressIndicator instance, which can be used to cancel action externally.

runInReadActionWithWriteActionPriority

public static boolean runInReadActionWithWriteActionPriority(java.lang.Runnable action)

This method attempts to run provided action synchronously in a read action, so that, if possible, it wouldn't impact any pending, executing or future write actions (for this to work effectively the action should invoke ProgressManager.checkCanceled() or ProgressIndicator.checkCanceled() often enough). It returns true if action was executed successfully. It returns false if the action was not executed successfully, i.e. if:

• write action was in progress when the method was called
• write action was pending when the method was called
• action started to execute, but was aborted using ProcessCanceledException when some other thread initiated write action

If caller needs to retry the invocation of this method in a loop, it should consider pausing between attempts, to avoid potential 100% CPU usage. There is also alternative that implements the re-trying logic NonBlockingReadAction

runWithWriteActionPriority

public static boolean runWithWriteActionPriority(java.lang.Runnable action,
                                                 ProgressIndicator progressIndicator)

scheduleWithWriteActionPriority

public static java.util.concurrent.CompletableFuture<?> scheduleWithWriteActionPriority(ProgressIndicator progressIndicator,
                                                                                        java.util.concurrent.Executor executor,
                                                                                        ReadTask readTask)

yieldToPendingWriteActions

public static void yieldToPendingWriteActions()

Ensure the current EDT activity finishes in case it requires many write actions, with each being delayed a bit by background thread read action (until its first checkCanceled call). Shouldn't be called from under read action.

withTimeout

public static <T> T withTimeout(long timeoutMs,
                                Computable<T> computation)

Run the given computation with its execution time restricted to the given amount of time in milliseconds.

Internally, it creates a new ProgressIndicator, runs the computation with that indicator and cancels it after the the timeout. The computation should call ProgressManager.checkCanceled() frequently enough, so that after the timeout has been exceeded it can stop the execution by throwing ProcessCanceledException, which will be caught by this withTimeout.

If a ProcessCanceledException happens due to any other reason (e.g. a thread's progress indicator got canceled), it'll be thrown out of this method.

Returns:

the computation result or null if timeout has been exceeded.

computeWithLockAndCheckingCanceled

public static <T,E extends java.lang.Throwable> T computeWithLockAndCheckingCanceled(java.util.concurrent.locks.Lock lock,
                                                                                     int timeout,
                                                                                     java.util.concurrent.TimeUnit timeUnit,
                                                                                     ThrowableComputable<T,E> computable)
                                                                              throws E extends java.lang.Throwable,
                                                                                     ProcessCanceledException

Throws:

E extends java.lang.Throwable

ProcessCanceledException

awaitWithCheckCanceled

public static void awaitWithCheckCanceled(java.util.concurrent.CountDownLatch waiter)

awaitWithCheckCanceled

public static <T> T awaitWithCheckCanceled(java.util.concurrent.Future<T> future)

awaitWithCheckCanceled

public static <T> T awaitWithCheckCanceled(java.util.concurrent.Future<T> future,
                                           ProgressIndicator indicator)

awaitWithCheckCanceled

public static void awaitWithCheckCanceled(java.util.concurrent.locks.Lock lock,
                                          int timeout,
                                          java.util.concurrent.TimeUnit timeUnit)

checkCancelledEvenWithPCEDisabled

public static void checkCancelledEvenWithPCEDisabled(ProgressIndicator indicator)

Use when otherwise a deadlock is possible.

awaitWithCheckCanceled

public static void awaitWithCheckCanceled(Semaphore semaphore,
                                          ProgressIndicator indicator)