LegacyConsole/jpexs-decompiler
3
0
Fork 0
mirror of https://git.huckle.dev/Huckles-Minecraft-Archive/jpexs-decompiler.git synced 2026-07-05 20:27:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Issue #431: Canceling background threads (after timeout, or after user action, e.g new treeitem selected) fixed + small fixes

Browse Source
This commit is contained in:
Honfika
2013-12-03 00:26:21 +01:00
parent 3aa09fdf2b
commit 06b95ac6e1
42 changed files with 1083 additions and 773 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
trunk/src/com/jpexs/helpers/Helper.java
View File

@@ -41,15 +41,6 @@ import java.util.Collection;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicReference;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
@@ -62,8 +53,6 @@ import java.util.regex.Pattern;
*/
public class Helper {
private static final ExecutorService THREAD_POOL = Executors.newCachedThreadPool();
/**
* Converts array of int values to string
*
@@ -625,61 +614,6 @@ public class Helper {
return data;
}
public static <T> T timedCall(Callable<T> c, long timeout, TimeUnit timeUnit) throws InterruptedException, ExecutionException, TimeoutException {
FutureTask<T> task = new FutureTask<>(c);
THREAD_POOL.execute(task);
try {
return task.get(timeout, timeUnit);
} finally {
task.cancel(true);
}
}
public static <T> FutureTask<T> callAsync(final Callable<T> c) {
return callAsync(c, null);
}
public static <T> FutureTask<T> callAsync(final Callable<T> c, final Callback<AsyncResult<T>> callback) {
FutureTask<T> task = new FutureTask<>(new Callable<T>() {
@Override
public T call() throws Exception {
try {
T t = c.call();
if (callback != null) {
callback.call(new AsyncResult<>(t, null));
}
return t;
} catch (Throwable ex) {
if (callback != null) {
callback.call(new AsyncResult<T>(null, ex));
}
throw ex;
}
}
});
THREAD_POOL.execute(task);
return task;
}
public static <T> T cancellableCall(final Callable<T> c, final AtomicReference<FutureTask<T>> cancellation) throws InterruptedException, ExecutionException {
FutureTask<T> task = new FutureTask<>(new Callable<T>() {
@Override
public T call() throws Exception {
T t = c.call();
return t;
}
});
cancellation.set(task);
THREAD_POOL.execute(task);
try {
return task.get();
} catch (CancellationException ex) {
throw new InterruptedException();
}
}
public static boolean contains(int[] array, int value) {
for (int i : array) {
if (i == value) {