mirror of
https://github.com/Pinball3D/Rabbit-R1.git
synced 2025-01-09 13:43:22 +00:00
1042 lines
42 KiB
Java
1042 lines
42 KiB
Java
package com.google.common.util.concurrent;
|
|
|
|
import com.google.common.base.Preconditions;
|
|
import com.google.common.base.Strings;
|
|
import com.google.common.base.Throwables;
|
|
import com.google.common.util.concurrent.internal.InternalFutureFailureAccess;
|
|
import com.google.common.util.concurrent.internal.InternalFutures;
|
|
import java.lang.reflect.Field;
|
|
import java.security.AccessController;
|
|
import java.security.PrivilegedActionException;
|
|
import java.security.PrivilegedExceptionAction;
|
|
import java.util.Locale;
|
|
import java.util.Objects;
|
|
import java.util.concurrent.CancellationException;
|
|
import java.util.concurrent.ExecutionException;
|
|
import java.util.concurrent.Executor;
|
|
import java.util.concurrent.Future;
|
|
import java.util.concurrent.ScheduledFuture;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.concurrent.TimeoutException;
|
|
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
|
|
import java.util.concurrent.locks.LockSupport;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
import javax.annotation.CheckForNull;
|
|
import sun.misc.Unsafe;
|
|
|
|
@ElementTypesAreNonnullByDefault
|
|
/* loaded from: classes3.dex */
|
|
public abstract class AbstractFuture<V> extends InternalFutureFailureAccess implements ListenableFuture<V> {
|
|
private static final AtomicHelper ATOMIC_HELPER;
|
|
static final boolean GENERATE_CANCELLATION_CAUSES;
|
|
private static final Object NULL;
|
|
private static final long SPIN_THRESHOLD_NANOS = 1000;
|
|
private static final Logger log;
|
|
|
|
@CheckForNull
|
|
private volatile Listener listeners;
|
|
|
|
@CheckForNull
|
|
private volatile Object value;
|
|
|
|
@CheckForNull
|
|
private volatile Waiter waiters;
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* loaded from: classes3.dex */
|
|
public interface Trusted<V> extends ListenableFuture<V> {
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
public void afterDone() {
|
|
}
|
|
|
|
protected void interruptTask() {
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
/* JADX WARN: Type inference failed for: r0v3, types: [java.lang.Throwable] */
|
|
/* JADX WARN: Type inference failed for: r0v6, types: [java.util.logging.Logger] */
|
|
/* JADX WARN: Type inference failed for: r1v2, types: [com.google.common.util.concurrent.AbstractFuture$1] */
|
|
/* JADX WARN: Type inference failed for: r1v3 */
|
|
/* JADX WARN: Type inference failed for: r1v4, types: [java.lang.Throwable] */
|
|
/* JADX WARN: Type inference failed for: r1v5 */
|
|
/* JADX WARN: Type inference failed for: r2v3, types: [com.google.common.util.concurrent.AbstractFuture$UnsafeAtomicHelper] */
|
|
/* JADX WARN: Type inference failed for: r9v0, types: [com.google.common.util.concurrent.AbstractFuture$SafeAtomicHelper] */
|
|
static {
|
|
boolean z;
|
|
SynchronizedHelper synchronizedHelper;
|
|
try {
|
|
z = Boolean.parseBoolean(System.getProperty("guava.concurrent.generate_cancellation_cause", "false"));
|
|
} catch (SecurityException unused) {
|
|
z = false;
|
|
}
|
|
GENERATE_CANCELLATION_CAUSES = z;
|
|
log = Logger.getLogger(AbstractFuture.class.getName());
|
|
?? r1 = 0;
|
|
r1 = 0;
|
|
try {
|
|
synchronizedHelper = new UnsafeAtomicHelper();
|
|
th = null;
|
|
} catch (Throwable th) {
|
|
th = th;
|
|
try {
|
|
synchronizedHelper = new SafeAtomicHelper(AtomicReferenceFieldUpdater.newUpdater(Waiter.class, Thread.class, "thread"), AtomicReferenceFieldUpdater.newUpdater(Waiter.class, Waiter.class, "next"), AtomicReferenceFieldUpdater.newUpdater(AbstractFuture.class, Waiter.class, "waiters"), AtomicReferenceFieldUpdater.newUpdater(AbstractFuture.class, Listener.class, "listeners"), AtomicReferenceFieldUpdater.newUpdater(AbstractFuture.class, Object.class, "value"));
|
|
} catch (Throwable th2) {
|
|
synchronizedHelper = new SynchronizedHelper();
|
|
r1 = th2;
|
|
}
|
|
}
|
|
ATOMIC_HELPER = synchronizedHelper;
|
|
if (r1 != 0) {
|
|
?? r0 = log;
|
|
r0.log(Level.SEVERE, "UnsafeAtomicHelper is broken!", th);
|
|
r0.log(Level.SEVERE, "SafeAtomicHelper is broken!", r1);
|
|
}
|
|
NULL = new Object();
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* loaded from: classes3.dex */
|
|
public static abstract class TrustedFuture<V> extends AbstractFuture<V> implements Trusted<V> {
|
|
@Override // com.google.common.util.concurrent.AbstractFuture, java.util.concurrent.Future
|
|
@ParametricNullness
|
|
public final V get() throws InterruptedException, ExecutionException {
|
|
return (V) super.get();
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture, java.util.concurrent.Future
|
|
@ParametricNullness
|
|
public final V get(long j, TimeUnit timeUnit) throws InterruptedException, ExecutionException, TimeoutException {
|
|
return (V) super.get(j, timeUnit);
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture, java.util.concurrent.Future
|
|
public final boolean isDone() {
|
|
return super.isDone();
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture, java.util.concurrent.Future
|
|
public final boolean isCancelled() {
|
|
return super.isCancelled();
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture, com.google.common.util.concurrent.ListenableFuture
|
|
public final void addListener(Runnable runnable, Executor executor) {
|
|
super.addListener(runnable, executor);
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture, java.util.concurrent.Future
|
|
public final boolean cancel(boolean z) {
|
|
return super.cancel(z);
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* loaded from: classes3.dex */
|
|
public static final class Waiter {
|
|
static final Waiter TOMBSTONE = new Waiter(false);
|
|
|
|
@CheckForNull
|
|
volatile Waiter next;
|
|
|
|
@CheckForNull
|
|
volatile Thread thread;
|
|
|
|
Waiter(boolean z) {
|
|
}
|
|
|
|
Waiter() {
|
|
AbstractFuture.ATOMIC_HELPER.putThread(this, Thread.currentThread());
|
|
}
|
|
|
|
void setNext(@CheckForNull Waiter waiter) {
|
|
AbstractFuture.ATOMIC_HELPER.putNext(this, waiter);
|
|
}
|
|
|
|
void unpark() {
|
|
Thread thread = this.thread;
|
|
if (thread != null) {
|
|
this.thread = null;
|
|
LockSupport.unpark(thread);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void removeWaiter(Waiter waiter) {
|
|
waiter.thread = null;
|
|
while (true) {
|
|
Waiter waiter2 = this.waiters;
|
|
if (waiter2 == Waiter.TOMBSTONE) {
|
|
return;
|
|
}
|
|
Waiter waiter3 = null;
|
|
while (waiter2 != null) {
|
|
Waiter waiter4 = waiter2.next;
|
|
if (waiter2.thread != null) {
|
|
waiter3 = waiter2;
|
|
} else if (waiter3 != null) {
|
|
waiter3.next = waiter4;
|
|
if (waiter3.thread == null) {
|
|
break;
|
|
}
|
|
} else if (!ATOMIC_HELPER.casWaiters(this, waiter2, waiter4)) {
|
|
break;
|
|
}
|
|
waiter2 = waiter4;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* loaded from: classes3.dex */
|
|
public static final class Listener {
|
|
static final Listener TOMBSTONE = new Listener();
|
|
|
|
@CheckForNull
|
|
final Executor executor;
|
|
|
|
@CheckForNull
|
|
Listener next;
|
|
|
|
@CheckForNull
|
|
final Runnable task;
|
|
|
|
Listener(Runnable runnable, Executor executor) {
|
|
this.task = runnable;
|
|
this.executor = executor;
|
|
}
|
|
|
|
Listener() {
|
|
this.task = null;
|
|
this.executor = null;
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* loaded from: classes3.dex */
|
|
public static final class Failure {
|
|
static final Failure FALLBACK_INSTANCE = new Failure(new Throwable("Failure occurred while trying to finish a future.") { // from class: com.google.common.util.concurrent.AbstractFuture.Failure.1
|
|
@Override // java.lang.Throwable
|
|
public synchronized Throwable fillInStackTrace() {
|
|
return this;
|
|
}
|
|
});
|
|
final Throwable exception;
|
|
|
|
Failure(Throwable th) {
|
|
this.exception = (Throwable) Preconditions.checkNotNull(th);
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* loaded from: classes3.dex */
|
|
public static final class Cancellation {
|
|
|
|
@CheckForNull
|
|
static final Cancellation CAUSELESS_CANCELLED;
|
|
|
|
@CheckForNull
|
|
static final Cancellation CAUSELESS_INTERRUPTED;
|
|
|
|
@CheckForNull
|
|
final Throwable cause;
|
|
final boolean wasInterrupted;
|
|
|
|
static {
|
|
if (AbstractFuture.GENERATE_CANCELLATION_CAUSES) {
|
|
CAUSELESS_CANCELLED = null;
|
|
CAUSELESS_INTERRUPTED = null;
|
|
} else {
|
|
CAUSELESS_CANCELLED = new Cancellation(false, null);
|
|
CAUSELESS_INTERRUPTED = new Cancellation(true, null);
|
|
}
|
|
}
|
|
|
|
Cancellation(boolean z, @CheckForNull Throwable th) {
|
|
this.wasInterrupted = z;
|
|
this.cause = th;
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* loaded from: classes3.dex */
|
|
public static final class SetFuture<V> implements Runnable {
|
|
final ListenableFuture<? extends V> future;
|
|
final AbstractFuture<V> owner;
|
|
|
|
SetFuture(AbstractFuture<V> abstractFuture, ListenableFuture<? extends V> listenableFuture) {
|
|
this.owner = abstractFuture;
|
|
this.future = listenableFuture;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (((AbstractFuture) this.owner).value != this) {
|
|
return;
|
|
}
|
|
if (AbstractFuture.ATOMIC_HELPER.casValue(this.owner, this, AbstractFuture.getFutureValue(this.future))) {
|
|
AbstractFuture.complete(this.owner);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // java.util.concurrent.Future
|
|
@ParametricNullness
|
|
public V get(long j, TimeUnit timeUnit) throws InterruptedException, TimeoutException, ExecutionException {
|
|
long nanos = timeUnit.toNanos(j);
|
|
if (Thread.interrupted()) {
|
|
throw new InterruptedException();
|
|
}
|
|
Object obj = this.value;
|
|
if ((obj != null) & (!(obj instanceof SetFuture))) {
|
|
return getDoneValue(obj);
|
|
}
|
|
long nanoTime = nanos > 0 ? System.nanoTime() + nanos : 0L;
|
|
if (nanos >= 1000) {
|
|
Waiter waiter = this.waiters;
|
|
if (waiter != Waiter.TOMBSTONE) {
|
|
Waiter waiter2 = new Waiter();
|
|
do {
|
|
waiter2.setNext(waiter);
|
|
if (ATOMIC_HELPER.casWaiters(this, waiter, waiter2)) {
|
|
do {
|
|
OverflowAvoidingLockSupport.parkNanos(this, nanos);
|
|
if (Thread.interrupted()) {
|
|
removeWaiter(waiter2);
|
|
throw new InterruptedException();
|
|
}
|
|
Object obj2 = this.value;
|
|
if ((obj2 != null) & (!(obj2 instanceof SetFuture))) {
|
|
return getDoneValue(obj2);
|
|
}
|
|
nanos = nanoTime - System.nanoTime();
|
|
} while (nanos >= 1000);
|
|
removeWaiter(waiter2);
|
|
} else {
|
|
waiter = this.waiters;
|
|
}
|
|
} while (waiter != Waiter.TOMBSTONE);
|
|
}
|
|
return getDoneValue(Objects.requireNonNull(this.value));
|
|
}
|
|
while (nanos > 0) {
|
|
Object obj3 = this.value;
|
|
if ((obj3 != null) & (!(obj3 instanceof SetFuture))) {
|
|
return getDoneValue(obj3);
|
|
}
|
|
if (Thread.interrupted()) {
|
|
throw new InterruptedException();
|
|
}
|
|
nanos = nanoTime - System.nanoTime();
|
|
}
|
|
String abstractFuture = toString();
|
|
String lowerCase = timeUnit.toString().toLowerCase(Locale.ROOT);
|
|
String lowerCase2 = timeUnit.toString().toLowerCase(Locale.ROOT);
|
|
String sb = new StringBuilder(String.valueOf(lowerCase2).length() + 28).append("Waited ").append(j).append(" ").append(lowerCase2).toString();
|
|
if (nanos + 1000 < 0) {
|
|
String concat = String.valueOf(sb).concat(" (plus ");
|
|
long j2 = -nanos;
|
|
long convert = timeUnit.convert(j2, TimeUnit.NANOSECONDS);
|
|
long nanos2 = j2 - timeUnit.toNanos(convert);
|
|
boolean z = convert == 0 || nanos2 > 1000;
|
|
if (convert > 0) {
|
|
String valueOf = String.valueOf(concat);
|
|
String sb2 = new StringBuilder(String.valueOf(valueOf).length() + 21 + String.valueOf(lowerCase).length()).append(valueOf).append(convert).append(" ").append(lowerCase).toString();
|
|
if (z) {
|
|
sb2 = String.valueOf(sb2).concat(",");
|
|
}
|
|
concat = String.valueOf(sb2).concat(" ");
|
|
}
|
|
if (z) {
|
|
String valueOf2 = String.valueOf(concat);
|
|
concat = new StringBuilder(String.valueOf(valueOf2).length() + 33).append(valueOf2).append(nanos2).append(" nanoseconds ").toString();
|
|
}
|
|
sb = String.valueOf(concat).concat("delay)");
|
|
}
|
|
if (isDone()) {
|
|
throw new TimeoutException(String.valueOf(sb).concat(" but future completed as timeout expired"));
|
|
}
|
|
throw new TimeoutException(new StringBuilder(String.valueOf(sb).length() + 5 + String.valueOf(abstractFuture).length()).append(sb).append(" for ").append(abstractFuture).toString());
|
|
}
|
|
|
|
@Override // java.util.concurrent.Future
|
|
@ParametricNullness
|
|
public V get() throws InterruptedException, ExecutionException {
|
|
Object obj;
|
|
if (Thread.interrupted()) {
|
|
throw new InterruptedException();
|
|
}
|
|
Object obj2 = this.value;
|
|
if ((obj2 != null) & (!(obj2 instanceof SetFuture))) {
|
|
return getDoneValue(obj2);
|
|
}
|
|
Waiter waiter = this.waiters;
|
|
if (waiter != Waiter.TOMBSTONE) {
|
|
Waiter waiter2 = new Waiter();
|
|
do {
|
|
waiter2.setNext(waiter);
|
|
if (ATOMIC_HELPER.casWaiters(this, waiter, waiter2)) {
|
|
do {
|
|
LockSupport.park(this);
|
|
if (Thread.interrupted()) {
|
|
removeWaiter(waiter2);
|
|
throw new InterruptedException();
|
|
}
|
|
obj = this.value;
|
|
} while (!((obj != null) & (!(obj instanceof SetFuture))));
|
|
return getDoneValue(obj);
|
|
}
|
|
waiter = this.waiters;
|
|
} while (waiter != Waiter.TOMBSTONE);
|
|
}
|
|
return getDoneValue(Objects.requireNonNull(this.value));
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
@ParametricNullness
|
|
private V getDoneValue(Object obj) throws ExecutionException {
|
|
if (obj instanceof Cancellation) {
|
|
throw cancellationExceptionWithCause("Task was cancelled.", ((Cancellation) obj).cause);
|
|
}
|
|
if (obj instanceof Failure) {
|
|
throw new ExecutionException(((Failure) obj).exception);
|
|
}
|
|
return obj == NULL ? (V) NullnessCasts.uncheckedNull() : obj;
|
|
}
|
|
|
|
@Override // java.util.concurrent.Future
|
|
public boolean isDone() {
|
|
return (!(r2 instanceof SetFuture)) & (this.value != null);
|
|
}
|
|
|
|
@Override // java.util.concurrent.Future
|
|
public boolean isCancelled() {
|
|
return this.value instanceof Cancellation;
|
|
}
|
|
|
|
@Override // java.util.concurrent.Future
|
|
public boolean cancel(boolean z) {
|
|
Cancellation cancellation;
|
|
Object requireNonNull;
|
|
Object obj = this.value;
|
|
if (!(obj == null) && !(obj instanceof SetFuture)) {
|
|
return false;
|
|
}
|
|
if (GENERATE_CANCELLATION_CAUSES) {
|
|
requireNonNull = new Cancellation(z, new CancellationException("Future.cancel() was called."));
|
|
} else {
|
|
if (z) {
|
|
cancellation = Cancellation.CAUSELESS_INTERRUPTED;
|
|
} else {
|
|
cancellation = Cancellation.CAUSELESS_CANCELLED;
|
|
}
|
|
requireNonNull = Objects.requireNonNull(cancellation);
|
|
}
|
|
boolean z2 = false;
|
|
while (true) {
|
|
if (ATOMIC_HELPER.casValue(this, obj, requireNonNull)) {
|
|
if (z) {
|
|
this.interruptTask();
|
|
}
|
|
complete(this);
|
|
if (!(obj instanceof SetFuture)) {
|
|
return true;
|
|
}
|
|
ListenableFuture<? extends V> listenableFuture = ((SetFuture) obj).future;
|
|
if (listenableFuture instanceof Trusted) {
|
|
this = (AbstractFuture) listenableFuture;
|
|
obj = this.value;
|
|
if (!(obj == null) && !(obj instanceof SetFuture)) {
|
|
return true;
|
|
}
|
|
z2 = true;
|
|
} else {
|
|
listenableFuture.cancel(z);
|
|
return true;
|
|
}
|
|
} else {
|
|
obj = this.value;
|
|
if (!(obj instanceof SetFuture)) {
|
|
return z2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
public final boolean wasInterrupted() {
|
|
Object obj = this.value;
|
|
return (obj instanceof Cancellation) && ((Cancellation) obj).wasInterrupted;
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.ListenableFuture
|
|
public void addListener(Runnable runnable, Executor executor) {
|
|
Listener listener;
|
|
Preconditions.checkNotNull(runnable, "Runnable was null.");
|
|
Preconditions.checkNotNull(executor, "Executor was null.");
|
|
if (!isDone() && (listener = this.listeners) != Listener.TOMBSTONE) {
|
|
Listener listener2 = new Listener(runnable, executor);
|
|
do {
|
|
listener2.next = listener;
|
|
if (ATOMIC_HELPER.casListeners(this, listener, listener2)) {
|
|
return;
|
|
} else {
|
|
listener = this.listeners;
|
|
}
|
|
} while (listener != Listener.TOMBSTONE);
|
|
}
|
|
executeListener(runnable, executor);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
public boolean set(@ParametricNullness V v) {
|
|
if (v == null) {
|
|
v = (V) NULL;
|
|
}
|
|
if (!ATOMIC_HELPER.casValue(this, null, v)) {
|
|
return false;
|
|
}
|
|
complete(this);
|
|
return true;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
public boolean setException(Throwable th) {
|
|
if (!ATOMIC_HELPER.casValue(this, null, new Failure((Throwable) Preconditions.checkNotNull(th)))) {
|
|
return false;
|
|
}
|
|
complete(this);
|
|
return true;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
public boolean setFuture(ListenableFuture<? extends V> listenableFuture) {
|
|
Failure failure;
|
|
Preconditions.checkNotNull(listenableFuture);
|
|
Object obj = this.value;
|
|
if (obj == null) {
|
|
if (listenableFuture.isDone()) {
|
|
if (!ATOMIC_HELPER.casValue(this, null, getFutureValue(listenableFuture))) {
|
|
return false;
|
|
}
|
|
complete(this);
|
|
return true;
|
|
}
|
|
SetFuture setFuture = new SetFuture(this, listenableFuture);
|
|
if (ATOMIC_HELPER.casValue(this, null, setFuture)) {
|
|
try {
|
|
listenableFuture.addListener(setFuture, DirectExecutor.INSTANCE);
|
|
} catch (Throwable th) {
|
|
try {
|
|
failure = new Failure(th);
|
|
} catch (Throwable unused) {
|
|
failure = Failure.FALLBACK_INSTANCE;
|
|
}
|
|
ATOMIC_HELPER.casValue(this, setFuture, failure);
|
|
}
|
|
return true;
|
|
}
|
|
obj = this.value;
|
|
}
|
|
if (obj instanceof Cancellation) {
|
|
listenableFuture.cancel(((Cancellation) obj).wasInterrupted);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public static Object getFutureValue(ListenableFuture<?> listenableFuture) {
|
|
Throwable tryInternalFastPathGetFailure;
|
|
if (listenableFuture instanceof Trusted) {
|
|
Object obj = ((AbstractFuture) listenableFuture).value;
|
|
if (obj instanceof Cancellation) {
|
|
Cancellation cancellation = (Cancellation) obj;
|
|
if (cancellation.wasInterrupted) {
|
|
obj = cancellation.cause != null ? new Cancellation(false, cancellation.cause) : Cancellation.CAUSELESS_CANCELLED;
|
|
}
|
|
}
|
|
return Objects.requireNonNull(obj);
|
|
}
|
|
if ((listenableFuture instanceof InternalFutureFailureAccess) && (tryInternalFastPathGetFailure = InternalFutures.tryInternalFastPathGetFailure((InternalFutureFailureAccess) listenableFuture)) != null) {
|
|
return new Failure(tryInternalFastPathGetFailure);
|
|
}
|
|
boolean isCancelled = listenableFuture.isCancelled();
|
|
if ((!GENERATE_CANCELLATION_CAUSES) & isCancelled) {
|
|
return Objects.requireNonNull(Cancellation.CAUSELESS_CANCELLED);
|
|
}
|
|
try {
|
|
Object uninterruptibly = getUninterruptibly(listenableFuture);
|
|
if (!isCancelled) {
|
|
return uninterruptibly == null ? NULL : uninterruptibly;
|
|
}
|
|
String valueOf = String.valueOf(listenableFuture);
|
|
return new Cancellation(false, new IllegalArgumentException(new StringBuilder(String.valueOf(valueOf).length() + 84).append("get() did not throw CancellationException, despite reporting isCancelled() == true: ").append(valueOf).toString()));
|
|
} catch (CancellationException e) {
|
|
if (!isCancelled) {
|
|
String valueOf2 = String.valueOf(listenableFuture);
|
|
return new Failure(new IllegalArgumentException(new StringBuilder(String.valueOf(valueOf2).length() + 77).append("get() threw CancellationException, despite reporting isCancelled() == false: ").append(valueOf2).toString(), e));
|
|
}
|
|
return new Cancellation(false, e);
|
|
} catch (ExecutionException e2) {
|
|
if (isCancelled) {
|
|
String valueOf3 = String.valueOf(listenableFuture);
|
|
return new Cancellation(false, new IllegalArgumentException(new StringBuilder(String.valueOf(valueOf3).length() + 84).append("get() did not throw CancellationException, despite reporting isCancelled() == true: ").append(valueOf3).toString(), e2));
|
|
}
|
|
return new Failure(e2.getCause());
|
|
} catch (Throwable th) {
|
|
return new Failure(th);
|
|
}
|
|
}
|
|
|
|
@ParametricNullness
|
|
private static <V> V getUninterruptibly(Future<V> future) throws ExecutionException {
|
|
V v;
|
|
boolean z = false;
|
|
while (true) {
|
|
try {
|
|
v = future.get();
|
|
break;
|
|
} catch (InterruptedException unused) {
|
|
z = true;
|
|
} catch (Throwable th) {
|
|
if (z) {
|
|
Thread.currentThread().interrupt();
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
if (z) {
|
|
Thread.currentThread().interrupt();
|
|
}
|
|
return v;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public static void complete(AbstractFuture<?> abstractFuture) {
|
|
Listener listener = null;
|
|
while (true) {
|
|
abstractFuture.releaseWaiters();
|
|
abstractFuture.afterDone();
|
|
Listener clearListeners = abstractFuture.clearListeners(listener);
|
|
while (clearListeners != null) {
|
|
listener = clearListeners.next;
|
|
Runnable runnable = (Runnable) Objects.requireNonNull(clearListeners.task);
|
|
if (runnable instanceof SetFuture) {
|
|
SetFuture setFuture = (SetFuture) runnable;
|
|
abstractFuture = setFuture.owner;
|
|
if (((AbstractFuture) abstractFuture).value == setFuture) {
|
|
if (ATOMIC_HELPER.casValue(abstractFuture, setFuture, getFutureValue(setFuture.future))) {
|
|
break;
|
|
}
|
|
} else {
|
|
continue;
|
|
}
|
|
} else {
|
|
executeListener(runnable, (Executor) Objects.requireNonNull(clearListeners.executor));
|
|
}
|
|
clearListeners = listener;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
@Override // com.google.common.util.concurrent.internal.InternalFutureFailureAccess
|
|
@CheckForNull
|
|
public final Throwable tryInternalFastPathGetFailure() {
|
|
if (!(this instanceof Trusted)) {
|
|
return null;
|
|
}
|
|
Object obj = this.value;
|
|
if (obj instanceof Failure) {
|
|
return ((Failure) obj).exception;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
public final void maybePropagateCancellationTo(@CheckForNull Future<?> future) {
|
|
if ((future != null) && isCancelled()) {
|
|
future.cancel(wasInterrupted());
|
|
}
|
|
}
|
|
|
|
private void releaseWaiters() {
|
|
for (Waiter gasWaiters = ATOMIC_HELPER.gasWaiters(this, Waiter.TOMBSTONE); gasWaiters != null; gasWaiters = gasWaiters.next) {
|
|
gasWaiters.unpark();
|
|
}
|
|
}
|
|
|
|
@CheckForNull
|
|
private Listener clearListeners(@CheckForNull Listener listener) {
|
|
Listener gasListeners = ATOMIC_HELPER.gasListeners(this, Listener.TOMBSTONE);
|
|
Listener listener2 = listener;
|
|
while (gasListeners != null) {
|
|
Listener listener3 = gasListeners.next;
|
|
gasListeners.next = listener2;
|
|
listener2 = gasListeners;
|
|
gasListeners = listener3;
|
|
}
|
|
return listener2;
|
|
}
|
|
|
|
public String toString() {
|
|
StringBuilder sb = new StringBuilder();
|
|
if (getClass().getName().startsWith("com.google.common.util.concurrent.")) {
|
|
sb.append(getClass().getSimpleName());
|
|
} else {
|
|
sb.append(getClass().getName());
|
|
}
|
|
sb.append('@').append(Integer.toHexString(System.identityHashCode(this))).append("[status=");
|
|
if (isCancelled()) {
|
|
sb.append("CANCELLED");
|
|
} else if (isDone()) {
|
|
addDoneString(sb);
|
|
} else {
|
|
addPendingString(sb);
|
|
}
|
|
return sb.append("]").toString();
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
@CheckForNull
|
|
public String pendingToString() {
|
|
if (!(this instanceof ScheduledFuture)) {
|
|
return null;
|
|
}
|
|
return new StringBuilder(41).append("remaining delay=[").append(((ScheduledFuture) this).getDelay(TimeUnit.MILLISECONDS)).append(" ms]").toString();
|
|
}
|
|
|
|
private void addPendingString(StringBuilder sb) {
|
|
String sb2;
|
|
int length = sb.length();
|
|
sb.append("PENDING");
|
|
Object obj = this.value;
|
|
if (obj instanceof SetFuture) {
|
|
sb.append(", setFuture=[");
|
|
appendUserObject(sb, ((SetFuture) obj).future);
|
|
sb.append("]");
|
|
} else {
|
|
try {
|
|
sb2 = Strings.emptyToNull(pendingToString());
|
|
} catch (RuntimeException | StackOverflowError e) {
|
|
String valueOf = String.valueOf(e.getClass());
|
|
sb2 = new StringBuilder(String.valueOf(valueOf).length() + 38).append("Exception thrown from implementation: ").append(valueOf).toString();
|
|
}
|
|
if (sb2 != null) {
|
|
sb.append(", info=[").append(sb2).append("]");
|
|
}
|
|
}
|
|
if (isDone()) {
|
|
sb.delete(length, sb.length());
|
|
addDoneString(sb);
|
|
}
|
|
}
|
|
|
|
private void addDoneString(StringBuilder sb) {
|
|
try {
|
|
Object uninterruptibly = getUninterruptibly(this);
|
|
sb.append("SUCCESS, result=[");
|
|
appendResultObject(sb, uninterruptibly);
|
|
sb.append("]");
|
|
} catch (CancellationException unused) {
|
|
sb.append("CANCELLED");
|
|
} catch (RuntimeException e) {
|
|
sb.append("UNKNOWN, cause=[").append(e.getClass()).append(" thrown from get()]");
|
|
} catch (ExecutionException e2) {
|
|
sb.append("FAILURE, cause=[").append(e2.getCause()).append("]");
|
|
}
|
|
}
|
|
|
|
private void appendResultObject(StringBuilder sb, @CheckForNull Object obj) {
|
|
if (obj == null) {
|
|
sb.append("null");
|
|
} else if (obj == this) {
|
|
sb.append("this future");
|
|
} else {
|
|
sb.append(obj.getClass().getName()).append("@").append(Integer.toHexString(System.identityHashCode(obj)));
|
|
}
|
|
}
|
|
|
|
private void appendUserObject(StringBuilder sb, @CheckForNull Object obj) {
|
|
try {
|
|
if (obj == this) {
|
|
sb.append("this future");
|
|
} else {
|
|
sb.append(obj);
|
|
}
|
|
} catch (RuntimeException | StackOverflowError e) {
|
|
sb.append("Exception thrown from implementation: ").append(e.getClass());
|
|
}
|
|
}
|
|
|
|
private static void executeListener(Runnable runnable, Executor executor) {
|
|
try {
|
|
executor.execute(runnable);
|
|
} catch (RuntimeException e) {
|
|
Logger logger = log;
|
|
Level level = Level.SEVERE;
|
|
String valueOf = String.valueOf(runnable);
|
|
String valueOf2 = String.valueOf(executor);
|
|
logger.log(level, new StringBuilder(String.valueOf(valueOf).length() + 57 + String.valueOf(valueOf2).length()).append("RuntimeException while executing runnable ").append(valueOf).append(" with executor ").append(valueOf2).toString(), (Throwable) e);
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* loaded from: classes3.dex */
|
|
public static abstract class AtomicHelper {
|
|
abstract boolean casListeners(AbstractFuture<?> abstractFuture, @CheckForNull Listener listener, Listener listener2);
|
|
|
|
abstract boolean casValue(AbstractFuture<?> abstractFuture, @CheckForNull Object obj, Object obj2);
|
|
|
|
abstract boolean casWaiters(AbstractFuture<?> abstractFuture, @CheckForNull Waiter waiter, @CheckForNull Waiter waiter2);
|
|
|
|
abstract Listener gasListeners(AbstractFuture<?> abstractFuture, Listener listener);
|
|
|
|
abstract Waiter gasWaiters(AbstractFuture<?> abstractFuture, Waiter waiter);
|
|
|
|
abstract void putNext(Waiter waiter, @CheckForNull Waiter waiter2);
|
|
|
|
abstract void putThread(Waiter waiter, Thread thread);
|
|
|
|
private AtomicHelper() {
|
|
}
|
|
}
|
|
|
|
/* loaded from: classes3.dex */
|
|
private static final class UnsafeAtomicHelper extends AtomicHelper {
|
|
static final long LISTENERS_OFFSET;
|
|
static final Unsafe UNSAFE;
|
|
static final long VALUE_OFFSET;
|
|
static final long WAITERS_OFFSET;
|
|
static final long WAITER_NEXT_OFFSET;
|
|
static final long WAITER_THREAD_OFFSET;
|
|
|
|
private UnsafeAtomicHelper() {
|
|
super();
|
|
}
|
|
|
|
static {
|
|
Unsafe unsafe;
|
|
try {
|
|
try {
|
|
unsafe = Unsafe.getUnsafe();
|
|
} catch (PrivilegedActionException e) {
|
|
throw new RuntimeException("Could not initialize intrinsics", e.getCause());
|
|
}
|
|
} catch (SecurityException unused) {
|
|
unsafe = (Unsafe) AccessController.doPrivileged(new PrivilegedExceptionAction<Unsafe>() { // from class: com.google.common.util.concurrent.AbstractFuture.UnsafeAtomicHelper.1
|
|
@Override // java.security.PrivilegedExceptionAction
|
|
public Unsafe run() throws Exception {
|
|
for (Field field : Unsafe.class.getDeclaredFields()) {
|
|
field.setAccessible(true);
|
|
Object obj = field.get(null);
|
|
if (Unsafe.class.isInstance(obj)) {
|
|
return (Unsafe) Unsafe.class.cast(obj);
|
|
}
|
|
}
|
|
throw new NoSuchFieldError("the Unsafe");
|
|
}
|
|
});
|
|
}
|
|
try {
|
|
WAITERS_OFFSET = unsafe.objectFieldOffset(AbstractFuture.class.getDeclaredField("waiters"));
|
|
LISTENERS_OFFSET = unsafe.objectFieldOffset(AbstractFuture.class.getDeclaredField("listeners"));
|
|
VALUE_OFFSET = unsafe.objectFieldOffset(AbstractFuture.class.getDeclaredField("value"));
|
|
WAITER_THREAD_OFFSET = unsafe.objectFieldOffset(Waiter.class.getDeclaredField("thread"));
|
|
WAITER_NEXT_OFFSET = unsafe.objectFieldOffset(Waiter.class.getDeclaredField("next"));
|
|
UNSAFE = unsafe;
|
|
} catch (Exception e2) {
|
|
Throwables.throwIfUnchecked(e2);
|
|
throw new RuntimeException(e2);
|
|
}
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
void putThread(Waiter waiter, Thread thread) {
|
|
UNSAFE.putObject(waiter, WAITER_THREAD_OFFSET, thread);
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
void putNext(Waiter waiter, @CheckForNull Waiter waiter2) {
|
|
UNSAFE.putObject(waiter, WAITER_NEXT_OFFSET, waiter2);
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
boolean casWaiters(AbstractFuture<?> abstractFuture, @CheckForNull Waiter waiter, @CheckForNull Waiter waiter2) {
|
|
return UNSAFE.compareAndSwapObject(abstractFuture, WAITERS_OFFSET, waiter, waiter2);
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
boolean casListeners(AbstractFuture<?> abstractFuture, @CheckForNull Listener listener, Listener listener2) {
|
|
return UNSAFE.compareAndSwapObject(abstractFuture, LISTENERS_OFFSET, listener, listener2);
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
Listener gasListeners(AbstractFuture<?> abstractFuture, Listener listener) {
|
|
Listener listener2;
|
|
do {
|
|
listener2 = ((AbstractFuture) abstractFuture).listeners;
|
|
if (listener == listener2) {
|
|
return listener2;
|
|
}
|
|
} while (!casListeners(abstractFuture, listener2, listener));
|
|
return listener2;
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
Waiter gasWaiters(AbstractFuture<?> abstractFuture, Waiter waiter) {
|
|
Waiter waiter2;
|
|
do {
|
|
waiter2 = ((AbstractFuture) abstractFuture).waiters;
|
|
if (waiter == waiter2) {
|
|
return waiter2;
|
|
}
|
|
} while (!casWaiters(abstractFuture, waiter2, waiter));
|
|
return waiter2;
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
boolean casValue(AbstractFuture<?> abstractFuture, @CheckForNull Object obj, Object obj2) {
|
|
return UNSAFE.compareAndSwapObject(abstractFuture, VALUE_OFFSET, obj, obj2);
|
|
}
|
|
}
|
|
|
|
/* loaded from: classes3.dex */
|
|
private static final class SafeAtomicHelper extends AtomicHelper {
|
|
final AtomicReferenceFieldUpdater<AbstractFuture, Listener> listenersUpdater;
|
|
final AtomicReferenceFieldUpdater<AbstractFuture, Object> valueUpdater;
|
|
final AtomicReferenceFieldUpdater<Waiter, Waiter> waiterNextUpdater;
|
|
final AtomicReferenceFieldUpdater<Waiter, Thread> waiterThreadUpdater;
|
|
final AtomicReferenceFieldUpdater<AbstractFuture, Waiter> waitersUpdater;
|
|
|
|
SafeAtomicHelper(AtomicReferenceFieldUpdater<Waiter, Thread> atomicReferenceFieldUpdater, AtomicReferenceFieldUpdater<Waiter, Waiter> atomicReferenceFieldUpdater2, AtomicReferenceFieldUpdater<AbstractFuture, Waiter> atomicReferenceFieldUpdater3, AtomicReferenceFieldUpdater<AbstractFuture, Listener> atomicReferenceFieldUpdater4, AtomicReferenceFieldUpdater<AbstractFuture, Object> atomicReferenceFieldUpdater5) {
|
|
super();
|
|
this.waiterThreadUpdater = atomicReferenceFieldUpdater;
|
|
this.waiterNextUpdater = atomicReferenceFieldUpdater2;
|
|
this.waitersUpdater = atomicReferenceFieldUpdater3;
|
|
this.listenersUpdater = atomicReferenceFieldUpdater4;
|
|
this.valueUpdater = atomicReferenceFieldUpdater5;
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
void putThread(Waiter waiter, Thread thread) {
|
|
this.waiterThreadUpdater.lazySet(waiter, thread);
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
void putNext(Waiter waiter, @CheckForNull Waiter waiter2) {
|
|
this.waiterNextUpdater.lazySet(waiter, waiter2);
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
boolean casWaiters(AbstractFuture<?> abstractFuture, @CheckForNull Waiter waiter, @CheckForNull Waiter waiter2) {
|
|
return this.waitersUpdater.compareAndSet(abstractFuture, waiter, waiter2);
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
boolean casListeners(AbstractFuture<?> abstractFuture, @CheckForNull Listener listener, Listener listener2) {
|
|
return this.listenersUpdater.compareAndSet(abstractFuture, listener, listener2);
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
Listener gasListeners(AbstractFuture<?> abstractFuture, Listener listener) {
|
|
return this.listenersUpdater.getAndSet(abstractFuture, listener);
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
Waiter gasWaiters(AbstractFuture<?> abstractFuture, Waiter waiter) {
|
|
return this.waitersUpdater.getAndSet(abstractFuture, waiter);
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
boolean casValue(AbstractFuture<?> abstractFuture, @CheckForNull Object obj, Object obj2) {
|
|
return this.valueUpdater.compareAndSet(abstractFuture, obj, obj2);
|
|
}
|
|
}
|
|
|
|
/* loaded from: classes3.dex */
|
|
private static final class SynchronizedHelper extends AtomicHelper {
|
|
private SynchronizedHelper() {
|
|
super();
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
void putThread(Waiter waiter, Thread thread) {
|
|
waiter.thread = thread;
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
void putNext(Waiter waiter, @CheckForNull Waiter waiter2) {
|
|
waiter.next = waiter2;
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
boolean casWaiters(AbstractFuture<?> abstractFuture, @CheckForNull Waiter waiter, @CheckForNull Waiter waiter2) {
|
|
synchronized (abstractFuture) {
|
|
if (((AbstractFuture) abstractFuture).waiters != waiter) {
|
|
return false;
|
|
}
|
|
((AbstractFuture) abstractFuture).waiters = waiter2;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
boolean casListeners(AbstractFuture<?> abstractFuture, @CheckForNull Listener listener, Listener listener2) {
|
|
synchronized (abstractFuture) {
|
|
if (((AbstractFuture) abstractFuture).listeners != listener) {
|
|
return false;
|
|
}
|
|
((AbstractFuture) abstractFuture).listeners = listener2;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
Listener gasListeners(AbstractFuture<?> abstractFuture, Listener listener) {
|
|
Listener listener2;
|
|
synchronized (abstractFuture) {
|
|
listener2 = ((AbstractFuture) abstractFuture).listeners;
|
|
if (listener2 != listener) {
|
|
((AbstractFuture) abstractFuture).listeners = listener;
|
|
}
|
|
}
|
|
return listener2;
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
Waiter gasWaiters(AbstractFuture<?> abstractFuture, Waiter waiter) {
|
|
Waiter waiter2;
|
|
synchronized (abstractFuture) {
|
|
waiter2 = ((AbstractFuture) abstractFuture).waiters;
|
|
if (waiter2 != waiter) {
|
|
((AbstractFuture) abstractFuture).waiters = waiter;
|
|
}
|
|
}
|
|
return waiter2;
|
|
}
|
|
|
|
@Override // com.google.common.util.concurrent.AbstractFuture.AtomicHelper
|
|
boolean casValue(AbstractFuture<?> abstractFuture, @CheckForNull Object obj, Object obj2) {
|
|
synchronized (abstractFuture) {
|
|
if (((AbstractFuture) abstractFuture).value != obj) {
|
|
return false;
|
|
}
|
|
((AbstractFuture) abstractFuture).value = obj2;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static CancellationException cancellationExceptionWithCause(String str, @CheckForNull Throwable th) {
|
|
CancellationException cancellationException = new CancellationException(str);
|
|
cancellationException.initCause(th);
|
|
return cancellationException;
|
|
}
|
|
}
|