This class is thread-safe. * * @hide */ public class ExecutorManager { private static final long AWAIT_DURATION_MS = 30 * 1000; /** * Creates a new {@link ExecutorService} with default settings for use in AppSearch. * *
The default settings are to use as many threads as there are CPUs. The core pool size is 1
* if cached executors should be used, or also the CPU number if fixed executors should be used.
*/
@NonNull
public static ExecutorService createDefaultExecutorService() {
boolean useFixedExecutorService =
FrameworkServiceAppSearchConfig.getUseFixedExecutorService();
int corePoolSize = useFixedExecutorService ? Runtime.getRuntime().availableProcessors() : 1;
long keepAliveTime = useFixedExecutorService ? 0L : 60L;
return AppSearchEnvironmentFactory.getEnvironmentInstance()
.createExecutorService(
/* corePoolSize= */ corePoolSize,
/* maxConcurrency= */ Runtime.getRuntime().availableProcessors(),
/* keepAliveTime= */ keepAliveTime,
/* unit= */ TimeUnit.SECONDS,
/* workQueue= */ new LinkedBlockingQueue<>(),
/* priority= */ 0); // priority is unused.
}
/**
* Creates a new {@link ExecutorService} with fixed thread settings for use in AppSearch.
*/
@NonNull
public static ExecutorService createReadOnlyExecutorService() {
return AppSearchEnvironmentFactory.getEnvironmentInstance()
.createExecutorService(
/* corePoolSize= */ 2,
/* maxConcurrency= */ 2,
/* keepAliveTime= */ 0L,
/* unit= */ TimeUnit.SECONDS,
/* workQueue= */ new LinkedBlockingQueue<>(),
/* priority= */ 0); // priority is unused.
}
/**
* Creates a new single-threaded {@link ScheduledExecutorService} for scheduling and running
* background tasks in AppSearch.
*/
@NonNull
public static ScheduledExecutorService createDefaultScheduledExecutorService() {
return Executors.newSingleThreadScheduledExecutor();
}
private final ServiceAppSearchConfig mAppSearchConfig;
private final boolean mIsIsolatedStorageAvailable;
/**
* A map of per-user executors for queued work. These can be started or shut down via this
* class's public API.
*/
@GuardedBy("mPerUserExecutorsLocked")
private final Map If AppSearch rate limiting is enabled, the input rate Limit config will be non-null, and
* the returned executor will be a RateLimitedExecutor instance.
*
* You are responsible for making sure not to call this for locked users. The executor will
* be created without problems but most operations on locked users will fail.
*/
@NonNull
public Executor getOrCreateUserExecutor(@NonNull UserHandle userHandle, boolean isReadOnly) {
Objects.requireNonNull(userHandle);
if (areSeparateReadWriteExecutorsEnabled(userHandle) && isReadOnly) {
synchronized (mPerUserReadOnlyExecutorsLocked) {
if (mAppSearchConfig.getCachedRateLimitEnabled()) {
return getOrCreateUserRateLimitedExecutorLocked(userHandle,
mPerUserReadOnlyExecutorsLocked,
ExecutorManager::createReadOnlyExecutorService,
mAppSearchConfig.getCachedRateLimitConfig());
} else {
return getOrCreateUserExecutorLocked(userHandle,
mPerUserReadOnlyExecutorsLocked,
ExecutorManager::createReadOnlyExecutorService);
}
}
} else {
synchronized (mPerUserExecutorsLocked) {
if (mAppSearchConfig.getCachedRateLimitEnabled()) {
return getOrCreateUserRateLimitedExecutorLocked(userHandle,
mPerUserExecutorsLocked, ExecutorManager::createDefaultExecutorService,
mAppSearchConfig.getCachedRateLimitConfig());
} else {
return getOrCreateUserExecutorLocked(userHandle, mPerUserExecutorsLocked,
ExecutorManager::createDefaultExecutorService);
}
}
}
}
/** Gets the scheduled executor service for the given user, creating it if it does not exist. */
@NonNull
public ScheduledExecutorService getOrCreateUserScheduledExecutor(
@NonNull UserHandle userHandle) {
Objects.requireNonNull(userHandle);
synchronized (mPerUserScheduledExecutorsLocked) {
ScheduledExecutorService executor = mPerUserScheduledExecutorsLocked.get(userHandle);
if (executor == null) {
executor = createDefaultScheduledExecutorService();
mPerUserScheduledExecutorsLocked.put(userHandle, executor);
}
return executor;
}
}
/**
* Gracefully shuts down the executor for the given user if there is one, waiting up to 30
* seconds for jobs to finish.
*/
public void shutDownAndRemoveUserExecutor(@NonNull UserHandle userHandle)
throws InterruptedException {
Objects.requireNonNull(userHandle);
ExecutorService executor;
synchronized (mPerUserExecutorsLocked) {
executor = mPerUserExecutorsLocked.remove(userHandle);
}
if (executor != null) {
executor.shutdown();
}
ExecutorService readOnlyExecutor = null;
if (areSeparateReadWriteExecutorsEnabled(userHandle)) {
synchronized (mPerUserReadOnlyExecutorsLocked) {
readOnlyExecutor = mPerUserReadOnlyExecutorsLocked.remove(userHandle);
}
if (readOnlyExecutor != null) {
readOnlyExecutor.shutdown();
}
}
ScheduledExecutorService scheduleExecutor;
synchronized (mPerUserScheduledExecutorsLocked) {
scheduleExecutor = mPerUserScheduledExecutorsLocked.remove(userHandle);
}
if (scheduleExecutor != null) {
scheduleExecutor.shutdown();
}
// Wait a little bit to finish outstanding requests. It's important not to call
// shutdownNow because nothing would pass a final result to the caller, leading to
// hangs. If we are interrupted or the timeout elapses, just move on to closing the
// user instance, meaning pending tasks may crash when AppSearchImpl closes under
// them.
long awaitStartTimeMs = SystemClock.elapsedRealtime();
long awaitDurationMs = AWAIT_DURATION_MS;
if (executor != null) {
executor.awaitTermination(awaitDurationMs, TimeUnit.MILLISECONDS);
}
if (areSeparateReadWriteExecutorsEnabled(userHandle)) {
awaitDurationMs =
AWAIT_DURATION_MS - (SystemClock.elapsedRealtime() - awaitStartTimeMs);
if (readOnlyExecutor != null && awaitDurationMs > 0) {
readOnlyExecutor.awaitTermination(awaitDurationMs, TimeUnit.MILLISECONDS);
}
}
awaitDurationMs = AWAIT_DURATION_MS - (SystemClock.elapsedRealtime() - awaitStartTimeMs);
if (scheduleExecutor != null && awaitDurationMs > 0) {
scheduleExecutor.awaitTermination(awaitDurationMs, TimeUnit.MILLISECONDS);
}
}
/**
* Helper to execute the implementation of some AppSearch functionality on the executor for that
* user.
*
* @param targetUser The verified user the call should run as.
* @param errorCallback Callback to complete with an error if starting the lambda fails.
* Otherwise this callback is not triggered.
* @param callingPackageName Package making this lambda call.
* @param apiType Api type of this lambda call.
* @param lambda The lambda to execute on the user-provided executor.
* @return true if the call is accepted by the executor and false otherwise.
*/
@BinderThread
@CanIgnoreReturnValue
public boolean executeLambdaForUserAsync(
@NonNull UserHandle targetUser,
@NonNull IAppSearchResultCallback errorCallback,
@NonNull String callingPackageName,
@CallStats.CallType int apiType,
@NonNull Runnable lambda) {
Objects.requireNonNull(targetUser);
Objects.requireNonNull(errorCallback);
Objects.requireNonNull(callingPackageName);
Objects.requireNonNull(lambda);
try {
boolean isReadOnly = isReadOnlyCall(apiType);
Executor executor = getOrCreateUserExecutor(targetUser, isReadOnly);
if (executor instanceof RateLimitedExecutor) {
boolean callAccepted =
((RateLimitedExecutor) executor)
.execute(lambda, callingPackageName, apiType);
if (!callAccepted) {
invokeCallbackOnResult(
errorCallback,
AppSearchResultParcel.fromFailedResult(
AppSearchResult.newFailedResult(
RESULT_RATE_LIMITED,
"AppSearch rate limit reached.")));
return false;
}
} else {
executor.execute(lambda);
}
} catch (RuntimeException e) {
AppSearchResult failedResult = throwableToFailedResult(e);
invokeCallbackOnResult(
errorCallback, AppSearchResultParcel.fromFailedResult(failedResult));
}
return true;
}
/**
* Helper to execute the implementation of some AppSearch functionality on the executor for that
* user.
*
* @param targetUser The verified user the call should run as.
* @param errorCallback Callback to complete with an error if starting the lambda fails.
* Otherwise this callback is not triggered.
* @param callingPackageName Package making this lambda call.
* @param apiType Api type of this lambda call.
* @param lambda The lambda to execute on the user-provided executor.
* @return true if the call is accepted by the executor and false otherwise.
*/
@BinderThread
public boolean executeLambdaForUserAsync(
@NonNull UserHandle targetUser,
@NonNull IAppSearchBatchResultCallback errorCallback,
@NonNull String callingPackageName,
@CallStats.CallType int apiType,
@NonNull Runnable lambda) {
Objects.requireNonNull(targetUser);
Objects.requireNonNull(errorCallback);
Objects.requireNonNull(callingPackageName);
Objects.requireNonNull(lambda);
try {
boolean isReadOnly = isReadOnlyCall(apiType);
Executor executor = getOrCreateUserExecutor(targetUser, isReadOnly);
if (executor instanceof RateLimitedExecutor) {
boolean callAccepted =
((RateLimitedExecutor) executor)
.execute(lambda, callingPackageName, apiType);
if (!callAccepted) {
invokeCallbackOnError(
errorCallback,
AppSearchResult.newFailedResult(
RESULT_RATE_LIMITED, "AppSearch rate limit reached."));
return false;
}
} else {
executor.execute(lambda);
}
} catch (RuntimeException e) {
invokeCallbackOnError(errorCallback, e);
}
return true;
}
/**
* Helper to execute the implementation of some AppSearch functionality on the executor for that
* user, without invoking callback for the user.
*
* @param targetUser The verified user the call should run as.
* @param callingPackageName Package making this lambda call.
* @param apiType Api type of this lambda call.
* @param lambda The lambda to execute on the user-provided executor.
* @return true if the call is accepted by the executor and false otherwise.
*/
@BinderThread
public boolean executeLambdaForUserNoCallbackAsync(
@NonNull UserHandle targetUser,
@NonNull String callingPackageName,
@CallStats.CallType int apiType,
@NonNull Runnable lambda) {
Objects.requireNonNull(targetUser);
Objects.requireNonNull(callingPackageName);
Objects.requireNonNull(lambda);
boolean isReadOnly = isReadOnlyCall(apiType);
Executor executor = getOrCreateUserExecutor(targetUser, isReadOnly);
if (executor instanceof RateLimitedExecutor) {
return ((RateLimitedExecutor) executor).execute(lambda, callingPackageName, apiType);
} else {
executor.execute(lambda);
return true;
}
}
/**
* Helper to execute the implementation of some AppSearch functionality on the executor for that
* user, without invoking callback for the user.
*
* @param targetUser The verified user the call should run as.
* @param isReadOnly Whether the given lambda performs only AppSearch read operations.
* @param lambda The lambda to execute on the user-provided executor.
*/
public void executeLambdaForUserNoCallbackAsync(
@NonNull UserHandle targetUser, boolean isReadOnly, @NonNull Runnable lambda) {
Objects.requireNonNull(targetUser);
Objects.requireNonNull(lambda);
getOrCreateUserExecutor(targetUser, isReadOnly).execute(lambda);
}
/**
* Schedules a task to be executed on the ScheduledExecutorService for the given user.
*
* @param targetUser The user for whom the task should be scheduled.
* @param lambda The task to be executed.
* @param delay The time from now to delay execution.
* @param unit The time unit of the delay parameter.
* @return the ScheduledFuture for the task.
*/
public ScheduledFuture scheduleLambdaForUserNoCallbackAsync(
@NonNull UserHandle targetUser,
@NonNull Runnable lambda,
long delay,
@NonNull TimeUnit unit) {
Objects.requireNonNull(targetUser);
Objects.requireNonNull(lambda);
Objects.requireNonNull(unit);
synchronized (mPerUserScheduledExecutorsLocked) {
return getOrCreateUserScheduledExecutor(targetUser).schedule(lambda, delay, unit);
}
}
@NonNull
private Executor getOrCreateUserExecutorLocked(@NonNull UserHandle userHandle,
@NonNull Map