blob: c30291b5270443b948450b4846ffdf0e03bc49dd (
about) (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.inputmethod.latin.utils;
import android.util.Log;
import com.android.inputmethod.annotations.UsedForTesting;
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
/**
* Utilities to manage executors.
*/
public class ExecutorUtils {
private static final String TAG = "ExecutorUtils";
private static ScheduledExecutorService sExecutorService =
Executors.newSingleThreadScheduledExecutor(new ExecutorFactory());
private static class ExecutorFactory implements ThreadFactory {
@Override
public Thread newThread(final Runnable runnable) {
Thread thread = new Thread(runnable, TAG);
thread.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread thread, Throwable ex) {
Log.w(TAG + "-" + runnable.getClass().getSimpleName(), ex);
}
});
return thread;
}
}
@UsedForTesting
private static ScheduledExecutorService sExecutorServiceForTests;
@UsedForTesting
public static void setExecutorServiceForTests(
final ScheduledExecutorService executorServiceForTests) {
sExecutorServiceForTests = executorServiceForTests;
}
//
// Public methods used to schedule a runnable for execution.
//
/**
* @return scheduled executor service used to run background tasks
*/
public static ScheduledExecutorService getBackgroundExecutor() {
if (sExecutorServiceForTests != null) {
return sExecutorServiceForTests;
}
return sExecutorService;
}
public static void killTasks() {
getBackgroundExecutor().shutdownNow();
try {
getBackgroundExecutor().awaitTermination(5, TimeUnit.SECONDS);
} catch (InterruptedException e) {
Log.wtf(TAG, "Failed to shut down background task.");
throw new IllegalStateException("Failed to shut down background task.");
} finally {
sExecutorService = Executors.newSingleThreadScheduledExecutor(new ExecutorFactory());
}
}
@UsedForTesting
public static Runnable chain(final Runnable... runnables) {
return new RunnableChain(runnables);
}
@UsedForTesting
public static class RunnableChain implements Runnable {
private final Runnable[] mRunnables;
private RunnableChain(final Runnable... runnables) {
if (runnables == null || runnables.length == 0) {
throw new IllegalArgumentException("Attempting to construct an empty chain");
}
mRunnables = runnables;
}
public Runnable[] getRunnables() {
return mRunnables;
}
@Override
public void run() {
for (Runnable runnable : mRunnables) {
if (Thread.interrupted()) {
return;
}
runnable.run();
}
}
}
}
|
