ADD week 5
This commit is contained in:
@ -0,0 +1,16 @@
|
||||
package androidx.concurrent.futures;
|
||||
|
||||
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
|
||||
|
||||
/* compiled from: D8$$SyntheticClass */
|
||||
/* loaded from: classes.dex */
|
||||
public final /* synthetic */ class AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0 {
|
||||
public static /* synthetic */ boolean m(AtomicReferenceFieldUpdater atomicReferenceFieldUpdater, Object obj, Object obj2, Object obj3) {
|
||||
while (!atomicReferenceFieldUpdater.compareAndSet(obj, obj2, obj3)) {
|
||||
if (atomicReferenceFieldUpdater.get(obj) != obj2) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,725 @@
|
||||
package androidx.concurrent.futures;
|
||||
|
||||
import com.google.common.util.concurrent.ListenableFuture;
|
||||
import java.util.Locale;
|
||||
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;
|
||||
|
||||
/* loaded from: classes.dex */
|
||||
public abstract class AbstractResolvableFuture<V> implements ListenableFuture<V> {
|
||||
static final AtomicHelper ATOMIC_HELPER;
|
||||
private static final Object NULL;
|
||||
private static final long SPIN_THRESHOLD_NANOS = 1000;
|
||||
volatile Listener listeners;
|
||||
volatile Object value;
|
||||
volatile Waiter waiters;
|
||||
static final boolean GENERATE_CANCELLATION_CAUSES = Boolean.parseBoolean(System.getProperty("guava.concurrent.generate_cancellation_cause", "false"));
|
||||
private static final Logger log = Logger.getLogger(AbstractResolvableFuture.class.getName());
|
||||
|
||||
protected void afterDone() {
|
||||
}
|
||||
|
||||
protected void interruptTask() {
|
||||
}
|
||||
|
||||
static {
|
||||
AtomicHelper synchronizedHelper;
|
||||
try {
|
||||
synchronizedHelper = new SafeAtomicHelper(AtomicReferenceFieldUpdater.newUpdater(Waiter.class, Thread.class, "thread"), AtomicReferenceFieldUpdater.newUpdater(Waiter.class, Waiter.class, "next"), AtomicReferenceFieldUpdater.newUpdater(AbstractResolvableFuture.class, Waiter.class, "waiters"), AtomicReferenceFieldUpdater.newUpdater(AbstractResolvableFuture.class, Listener.class, "listeners"), AtomicReferenceFieldUpdater.newUpdater(AbstractResolvableFuture.class, Object.class, "value"));
|
||||
th = null;
|
||||
} catch (Throwable th) {
|
||||
th = th;
|
||||
synchronizedHelper = new SynchronizedHelper();
|
||||
}
|
||||
ATOMIC_HELPER = synchronizedHelper;
|
||||
if (th != null) {
|
||||
log.log(Level.SEVERE, "SafeAtomicHelper is broken!", th);
|
||||
}
|
||||
NULL = new Object();
|
||||
}
|
||||
|
||||
private static final class Waiter {
|
||||
static final Waiter TOMBSTONE = new Waiter(false);
|
||||
volatile Waiter next;
|
||||
volatile Thread thread;
|
||||
|
||||
Waiter(boolean z) {
|
||||
}
|
||||
|
||||
Waiter() {
|
||||
AbstractResolvableFuture.ATOMIC_HELPER.putThread(this, Thread.currentThread());
|
||||
}
|
||||
|
||||
void setNext(Waiter waiter) {
|
||||
AbstractResolvableFuture.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;
|
||||
}
|
||||
}
|
||||
|
||||
private static final class Listener {
|
||||
static final Listener TOMBSTONE = new Listener(null, null);
|
||||
final Executor executor;
|
||||
Listener next;
|
||||
final Runnable task;
|
||||
|
||||
Listener(Runnable runnable, Executor executor) {
|
||||
this.task = runnable;
|
||||
this.executor = executor;
|
||||
}
|
||||
}
|
||||
|
||||
private static final class Failure {
|
||||
static final Failure FALLBACK_INSTANCE = new Failure(new Throwable("Failure occurred while trying to finish a future.") { // from class: androidx.concurrent.futures.AbstractResolvableFuture.Failure.1
|
||||
@Override // java.lang.Throwable
|
||||
public synchronized Throwable fillInStackTrace() {
|
||||
return this;
|
||||
}
|
||||
});
|
||||
final Throwable exception;
|
||||
|
||||
Failure(Throwable th) {
|
||||
this.exception = (Throwable) AbstractResolvableFuture.checkNotNull(th);
|
||||
}
|
||||
}
|
||||
|
||||
private static final class Cancellation {
|
||||
static final Cancellation CAUSELESS_CANCELLED;
|
||||
static final Cancellation CAUSELESS_INTERRUPTED;
|
||||
final Throwable cause;
|
||||
final boolean wasInterrupted;
|
||||
|
||||
static {
|
||||
if (AbstractResolvableFuture.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, Throwable th) {
|
||||
this.wasInterrupted = z;
|
||||
this.cause = th;
|
||||
}
|
||||
}
|
||||
|
||||
private static final class SetFuture<V> implements Runnable {
|
||||
final ListenableFuture<? extends V> future;
|
||||
final AbstractResolvableFuture<V> owner;
|
||||
|
||||
SetFuture(AbstractResolvableFuture<V> abstractResolvableFuture, ListenableFuture<? extends V> listenableFuture) {
|
||||
this.owner = abstractResolvableFuture;
|
||||
this.future = listenableFuture;
|
||||
}
|
||||
|
||||
@Override // java.lang.Runnable
|
||||
public void run() {
|
||||
if (this.owner.value != this) {
|
||||
return;
|
||||
}
|
||||
if (AbstractResolvableFuture.ATOMIC_HELPER.casValue(this.owner, this, AbstractResolvableFuture.getFutureValue(this.future))) {
|
||||
AbstractResolvableFuture.complete(this.owner);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected AbstractResolvableFuture() {
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Future
|
||||
public final 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 >= SPIN_THRESHOLD_NANOS) {
|
||||
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.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 >= SPIN_THRESHOLD_NANOS);
|
||||
removeWaiter(waiter2);
|
||||
} else {
|
||||
waiter = this.waiters;
|
||||
}
|
||||
} while (waiter != Waiter.TOMBSTONE);
|
||||
}
|
||||
return getDoneValue(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 abstractResolvableFuture = toString();
|
||||
String lowerCase = timeUnit.toString().toLowerCase(Locale.ROOT);
|
||||
String str = "Waited " + j + " " + timeUnit.toString().toLowerCase(Locale.ROOT);
|
||||
if (nanos + SPIN_THRESHOLD_NANOS < 0) {
|
||||
String str2 = str + " (plus ";
|
||||
long j2 = -nanos;
|
||||
long convert = timeUnit.convert(j2, TimeUnit.NANOSECONDS);
|
||||
long nanos2 = j2 - timeUnit.toNanos(convert);
|
||||
boolean z = convert == 0 || nanos2 > SPIN_THRESHOLD_NANOS;
|
||||
if (convert > 0) {
|
||||
String str3 = str2 + convert + " " + lowerCase;
|
||||
if (z) {
|
||||
str3 = str3 + ",";
|
||||
}
|
||||
str2 = str3 + " ";
|
||||
}
|
||||
if (z) {
|
||||
str2 = str2 + nanos2 + " nanoseconds ";
|
||||
}
|
||||
str = str2 + "delay)";
|
||||
}
|
||||
if (isDone()) {
|
||||
throw new TimeoutException(str + " but future completed as timeout expired");
|
||||
}
|
||||
throw new TimeoutException(str + " for " + abstractResolvableFuture);
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Future
|
||||
public final 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(this.value);
|
||||
}
|
||||
|
||||
/* JADX WARN: Multi-variable type inference failed */
|
||||
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);
|
||||
}
|
||||
if (obj == NULL) {
|
||||
return null;
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Future
|
||||
public final boolean isDone() {
|
||||
return (!(r0 instanceof SetFuture)) & (this.value != null);
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Future
|
||||
public final boolean isCancelled() {
|
||||
return this.value instanceof Cancellation;
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Future
|
||||
public final boolean cancel(boolean z) {
|
||||
Cancellation cancellation;
|
||||
Object obj = this.value;
|
||||
if (!(obj == null) && !(obj instanceof SetFuture)) {
|
||||
return false;
|
||||
}
|
||||
if (GENERATE_CANCELLATION_CAUSES) {
|
||||
cancellation = new Cancellation(z, new CancellationException("Future.cancel() was called."));
|
||||
} else if (z) {
|
||||
cancellation = Cancellation.CAUSELESS_INTERRUPTED;
|
||||
} else {
|
||||
cancellation = Cancellation.CAUSELESS_CANCELLED;
|
||||
}
|
||||
boolean z2 = false;
|
||||
AbstractResolvableFuture<V> abstractResolvableFuture = this;
|
||||
while (true) {
|
||||
if (ATOMIC_HELPER.casValue(abstractResolvableFuture, obj, cancellation)) {
|
||||
if (z) {
|
||||
abstractResolvableFuture.interruptTask();
|
||||
}
|
||||
complete(abstractResolvableFuture);
|
||||
if (!(obj instanceof SetFuture)) {
|
||||
return true;
|
||||
}
|
||||
ListenableFuture<? extends V> listenableFuture = ((SetFuture) obj).future;
|
||||
if (listenableFuture instanceof AbstractResolvableFuture) {
|
||||
abstractResolvableFuture = (AbstractResolvableFuture) listenableFuture;
|
||||
obj = abstractResolvableFuture.value;
|
||||
if (!(obj == null) && !(obj instanceof SetFuture)) {
|
||||
return true;
|
||||
}
|
||||
z2 = true;
|
||||
} else {
|
||||
listenableFuture.cancel(z);
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
obj = abstractResolvableFuture.value;
|
||||
if (!(obj instanceof SetFuture)) {
|
||||
return z2;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected final boolean wasInterrupted() {
|
||||
Object obj = this.value;
|
||||
return (obj instanceof Cancellation) && ((Cancellation) obj).wasInterrupted;
|
||||
}
|
||||
|
||||
@Override // com.google.common.util.concurrent.ListenableFuture
|
||||
public final void addListener(Runnable runnable, Executor executor) {
|
||||
checkNotNull(runnable);
|
||||
checkNotNull(executor);
|
||||
Listener listener = this.listeners;
|
||||
if (listener != 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);
|
||||
}
|
||||
|
||||
protected boolean set(V v) {
|
||||
if (v == null) {
|
||||
v = (V) NULL;
|
||||
}
|
||||
if (!ATOMIC_HELPER.casValue(this, null, v)) {
|
||||
return false;
|
||||
}
|
||||
complete(this);
|
||||
return true;
|
||||
}
|
||||
|
||||
protected boolean setException(Throwable th) {
|
||||
if (!ATOMIC_HELPER.casValue(this, null, new Failure((Throwable) checkNotNull(th)))) {
|
||||
return false;
|
||||
}
|
||||
complete(this);
|
||||
return true;
|
||||
}
|
||||
|
||||
protected boolean setFuture(ListenableFuture<? extends V> listenableFuture) {
|
||||
Failure failure;
|
||||
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;
|
||||
}
|
||||
|
||||
static Object getFutureValue(ListenableFuture<?> listenableFuture) {
|
||||
if (listenableFuture instanceof AbstractResolvableFuture) {
|
||||
Object obj = ((AbstractResolvableFuture) listenableFuture).value;
|
||||
if (!(obj instanceof Cancellation)) {
|
||||
return obj;
|
||||
}
|
||||
Cancellation cancellation = (Cancellation) obj;
|
||||
return cancellation.wasInterrupted ? cancellation.cause != null ? new Cancellation(false, cancellation.cause) : Cancellation.CAUSELESS_CANCELLED : obj;
|
||||
}
|
||||
boolean isCancelled = listenableFuture.isCancelled();
|
||||
if ((!GENERATE_CANCELLATION_CAUSES) & isCancelled) {
|
||||
return Cancellation.CAUSELESS_CANCELLED;
|
||||
}
|
||||
try {
|
||||
Object uninterruptibly = getUninterruptibly(listenableFuture);
|
||||
return uninterruptibly == null ? NULL : uninterruptibly;
|
||||
} catch (CancellationException e) {
|
||||
if (!isCancelled) {
|
||||
return new Failure(new IllegalArgumentException("get() threw CancellationException, despite reporting isCancelled() == false: " + listenableFuture, e));
|
||||
}
|
||||
return new Cancellation(false, e);
|
||||
} catch (ExecutionException e2) {
|
||||
return new Failure(e2.getCause());
|
||||
} catch (Throwable th) {
|
||||
return new Failure(th);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
static void complete(AbstractResolvableFuture<?> abstractResolvableFuture) {
|
||||
Listener listener = null;
|
||||
while (true) {
|
||||
abstractResolvableFuture.releaseWaiters();
|
||||
abstractResolvableFuture.afterDone();
|
||||
Listener clearListeners = abstractResolvableFuture.clearListeners(listener);
|
||||
while (clearListeners != null) {
|
||||
listener = clearListeners.next;
|
||||
Runnable runnable = clearListeners.task;
|
||||
if (runnable instanceof SetFuture) {
|
||||
SetFuture setFuture = (SetFuture) runnable;
|
||||
abstractResolvableFuture = setFuture.owner;
|
||||
if (abstractResolvableFuture.value == setFuture) {
|
||||
if (ATOMIC_HELPER.casValue(abstractResolvableFuture, setFuture, getFutureValue(setFuture.future))) {
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
executeListener(runnable, clearListeners.executor);
|
||||
}
|
||||
clearListeners = listener;
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
final void maybePropagateCancellationTo(Future<?> future) {
|
||||
if ((future != null) && isCancelled()) {
|
||||
future.cancel(wasInterrupted());
|
||||
}
|
||||
}
|
||||
|
||||
private void releaseWaiters() {
|
||||
Waiter waiter;
|
||||
do {
|
||||
waiter = this.waiters;
|
||||
} while (!ATOMIC_HELPER.casWaiters(this, waiter, Waiter.TOMBSTONE));
|
||||
while (waiter != null) {
|
||||
waiter.unpark();
|
||||
waiter = waiter.next;
|
||||
}
|
||||
}
|
||||
|
||||
private Listener clearListeners(Listener listener) {
|
||||
Listener listener2;
|
||||
do {
|
||||
listener2 = this.listeners;
|
||||
} while (!ATOMIC_HELPER.casListeners(this, listener2, Listener.TOMBSTONE));
|
||||
Listener listener3 = listener;
|
||||
Listener listener4 = listener2;
|
||||
while (listener4 != null) {
|
||||
Listener listener5 = listener4.next;
|
||||
listener4.next = listener3;
|
||||
listener3 = listener4;
|
||||
listener4 = listener5;
|
||||
}
|
||||
return listener3;
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
String str;
|
||||
StringBuilder sb = new StringBuilder();
|
||||
sb.append(super.toString());
|
||||
sb.append("[status=");
|
||||
if (isCancelled()) {
|
||||
sb.append("CANCELLED");
|
||||
} else if (isDone()) {
|
||||
addDoneString(sb);
|
||||
} else {
|
||||
try {
|
||||
str = pendingToString();
|
||||
} catch (RuntimeException e) {
|
||||
str = "Exception thrown from implementation: " + e.getClass();
|
||||
}
|
||||
if (str != null && !str.isEmpty()) {
|
||||
sb.append("PENDING, info=[");
|
||||
sb.append(str);
|
||||
sb.append("]");
|
||||
} else if (isDone()) {
|
||||
addDoneString(sb);
|
||||
} else {
|
||||
sb.append("PENDING");
|
||||
}
|
||||
}
|
||||
sb.append("]");
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
/* JADX WARN: Multi-variable type inference failed */
|
||||
protected String pendingToString() {
|
||||
Object obj = this.value;
|
||||
if (obj instanceof SetFuture) {
|
||||
return "setFuture=[" + userObjectToString(((SetFuture) obj).future) + "]";
|
||||
}
|
||||
if (!(this instanceof ScheduledFuture)) {
|
||||
return null;
|
||||
}
|
||||
return "remaining delay=[" + ((ScheduledFuture) this).getDelay(TimeUnit.MILLISECONDS) + " ms]";
|
||||
}
|
||||
|
||||
private void addDoneString(StringBuilder sb) {
|
||||
try {
|
||||
Object uninterruptibly = getUninterruptibly(this);
|
||||
sb.append("SUCCESS, result=[");
|
||||
sb.append(userObjectToString(uninterruptibly));
|
||||
sb.append("]");
|
||||
} catch (CancellationException unused) {
|
||||
sb.append("CANCELLED");
|
||||
} catch (RuntimeException e) {
|
||||
sb.append("UNKNOWN, cause=[");
|
||||
sb.append(e.getClass());
|
||||
sb.append(" thrown from get()]");
|
||||
} catch (ExecutionException e2) {
|
||||
sb.append("FAILURE, cause=[");
|
||||
sb.append(e2.getCause());
|
||||
sb.append("]");
|
||||
}
|
||||
}
|
||||
|
||||
private String userObjectToString(Object obj) {
|
||||
return obj == this ? "this future" : String.valueOf(obj);
|
||||
}
|
||||
|
||||
private static void executeListener(Runnable runnable, Executor executor) {
|
||||
try {
|
||||
executor.execute(runnable);
|
||||
} catch (RuntimeException e) {
|
||||
log.log(Level.SEVERE, "RuntimeException while executing runnable " + runnable + " with executor " + executor, (Throwable) e);
|
||||
}
|
||||
}
|
||||
|
||||
private static abstract class AtomicHelper {
|
||||
abstract boolean casListeners(AbstractResolvableFuture<?> abstractResolvableFuture, Listener listener, Listener listener2);
|
||||
|
||||
abstract boolean casValue(AbstractResolvableFuture<?> abstractResolvableFuture, Object obj, Object obj2);
|
||||
|
||||
abstract boolean casWaiters(AbstractResolvableFuture<?> abstractResolvableFuture, Waiter waiter, Waiter waiter2);
|
||||
|
||||
abstract void putNext(Waiter waiter, Waiter waiter2);
|
||||
|
||||
abstract void putThread(Waiter waiter, Thread thread);
|
||||
|
||||
private AtomicHelper() {
|
||||
}
|
||||
}
|
||||
|
||||
private static final class SafeAtomicHelper extends AtomicHelper {
|
||||
final AtomicReferenceFieldUpdater<AbstractResolvableFuture, Listener> listenersUpdater;
|
||||
final AtomicReferenceFieldUpdater<AbstractResolvableFuture, Object> valueUpdater;
|
||||
final AtomicReferenceFieldUpdater<Waiter, Waiter> waiterNextUpdater;
|
||||
final AtomicReferenceFieldUpdater<Waiter, Thread> waiterThreadUpdater;
|
||||
final AtomicReferenceFieldUpdater<AbstractResolvableFuture, Waiter> waitersUpdater;
|
||||
|
||||
SafeAtomicHelper(AtomicReferenceFieldUpdater<Waiter, Thread> atomicReferenceFieldUpdater, AtomicReferenceFieldUpdater<Waiter, Waiter> atomicReferenceFieldUpdater2, AtomicReferenceFieldUpdater<AbstractResolvableFuture, Waiter> atomicReferenceFieldUpdater3, AtomicReferenceFieldUpdater<AbstractResolvableFuture, Listener> atomicReferenceFieldUpdater4, AtomicReferenceFieldUpdater<AbstractResolvableFuture, Object> atomicReferenceFieldUpdater5) {
|
||||
super();
|
||||
this.waiterThreadUpdater = atomicReferenceFieldUpdater;
|
||||
this.waiterNextUpdater = atomicReferenceFieldUpdater2;
|
||||
this.waitersUpdater = atomicReferenceFieldUpdater3;
|
||||
this.listenersUpdater = atomicReferenceFieldUpdater4;
|
||||
this.valueUpdater = atomicReferenceFieldUpdater5;
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture.AtomicHelper
|
||||
void putThread(Waiter waiter, Thread thread) {
|
||||
this.waiterThreadUpdater.lazySet(waiter, thread);
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture.AtomicHelper
|
||||
void putNext(Waiter waiter, Waiter waiter2) {
|
||||
this.waiterNextUpdater.lazySet(waiter, waiter2);
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture.AtomicHelper
|
||||
boolean casWaiters(AbstractResolvableFuture<?> abstractResolvableFuture, Waiter waiter, Waiter waiter2) {
|
||||
return AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(this.waitersUpdater, abstractResolvableFuture, waiter, waiter2);
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture.AtomicHelper
|
||||
boolean casListeners(AbstractResolvableFuture<?> abstractResolvableFuture, Listener listener, Listener listener2) {
|
||||
return AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(this.listenersUpdater, abstractResolvableFuture, listener, listener2);
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture.AtomicHelper
|
||||
boolean casValue(AbstractResolvableFuture<?> abstractResolvableFuture, Object obj, Object obj2) {
|
||||
return AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(this.valueUpdater, abstractResolvableFuture, obj, obj2);
|
||||
}
|
||||
}
|
||||
|
||||
private static final class SynchronizedHelper extends AtomicHelper {
|
||||
SynchronizedHelper() {
|
||||
super();
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture.AtomicHelper
|
||||
void putThread(Waiter waiter, Thread thread) {
|
||||
waiter.thread = thread;
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture.AtomicHelper
|
||||
void putNext(Waiter waiter, Waiter waiter2) {
|
||||
waiter.next = waiter2;
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture.AtomicHelper
|
||||
boolean casWaiters(AbstractResolvableFuture<?> abstractResolvableFuture, Waiter waiter, Waiter waiter2) {
|
||||
synchronized (abstractResolvableFuture) {
|
||||
if (abstractResolvableFuture.waiters != waiter) {
|
||||
return false;
|
||||
}
|
||||
abstractResolvableFuture.waiters = waiter2;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture.AtomicHelper
|
||||
boolean casListeners(AbstractResolvableFuture<?> abstractResolvableFuture, Listener listener, Listener listener2) {
|
||||
synchronized (abstractResolvableFuture) {
|
||||
if (abstractResolvableFuture.listeners != listener) {
|
||||
return false;
|
||||
}
|
||||
abstractResolvableFuture.listeners = listener2;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture.AtomicHelper
|
||||
boolean casValue(AbstractResolvableFuture<?> abstractResolvableFuture, Object obj, Object obj2) {
|
||||
synchronized (abstractResolvableFuture) {
|
||||
if (abstractResolvableFuture.value != obj) {
|
||||
return false;
|
||||
}
|
||||
abstractResolvableFuture.value = obj2;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static CancellationException cancellationExceptionWithCause(String str, Throwable th) {
|
||||
CancellationException cancellationException = new CancellationException(str);
|
||||
cancellationException.initCause(th);
|
||||
return cancellationException;
|
||||
}
|
||||
|
||||
static <T> T checkNotNull(T t) {
|
||||
t.getClass();
|
||||
return t;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,186 @@
|
||||
package androidx.concurrent.futures;
|
||||
|
||||
import com.google.common.util.concurrent.ListenableFuture;
|
||||
import java.lang.ref.WeakReference;
|
||||
import java.util.concurrent.ExecutionException;
|
||||
import java.util.concurrent.Executor;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.TimeoutException;
|
||||
|
||||
/* loaded from: classes.dex */
|
||||
public final class CallbackToFutureAdapter {
|
||||
|
||||
public interface Resolver<T> {
|
||||
Object attachCompleter(Completer<T> completer) throws Exception;
|
||||
}
|
||||
|
||||
private CallbackToFutureAdapter() {
|
||||
}
|
||||
|
||||
public static <T> ListenableFuture<T> getFuture(Resolver<T> resolver) {
|
||||
Completer<T> completer = new Completer<>();
|
||||
SafeFuture<T> safeFuture = new SafeFuture<>(completer);
|
||||
completer.future = safeFuture;
|
||||
completer.tag = resolver.getClass();
|
||||
try {
|
||||
Object attachCompleter = resolver.attachCompleter(completer);
|
||||
if (attachCompleter != null) {
|
||||
completer.tag = attachCompleter;
|
||||
}
|
||||
} catch (Exception e) {
|
||||
safeFuture.setException(e);
|
||||
}
|
||||
return safeFuture;
|
||||
}
|
||||
|
||||
private static final class SafeFuture<T> implements ListenableFuture<T> {
|
||||
final WeakReference<Completer<T>> completerWeakReference;
|
||||
private final AbstractResolvableFuture<T> delegate = new AbstractResolvableFuture<T>() { // from class: androidx.concurrent.futures.CallbackToFutureAdapter.SafeFuture.1
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture
|
||||
protected String pendingToString() {
|
||||
Completer<T> completer = SafeFuture.this.completerWeakReference.get();
|
||||
if (completer == null) {
|
||||
return "Completer object has been garbage collected, future will fail soon";
|
||||
}
|
||||
return "tag=[" + completer.tag + "]";
|
||||
}
|
||||
};
|
||||
|
||||
SafeFuture(Completer<T> completer) {
|
||||
this.completerWeakReference = new WeakReference<>(completer);
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Future
|
||||
public boolean cancel(boolean z) {
|
||||
Completer<T> completer = this.completerWeakReference.get();
|
||||
boolean cancel = this.delegate.cancel(z);
|
||||
if (cancel && completer != null) {
|
||||
completer.fireCancellationListeners();
|
||||
}
|
||||
return cancel;
|
||||
}
|
||||
|
||||
boolean cancelWithoutNotifyingCompleter(boolean z) {
|
||||
return this.delegate.cancel(z);
|
||||
}
|
||||
|
||||
boolean set(T t) {
|
||||
return this.delegate.set(t);
|
||||
}
|
||||
|
||||
boolean setException(Throwable th) {
|
||||
return this.delegate.setException(th);
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Future
|
||||
public boolean isCancelled() {
|
||||
return this.delegate.isCancelled();
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Future
|
||||
public boolean isDone() {
|
||||
return this.delegate.isDone();
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Future
|
||||
public T get() throws InterruptedException, ExecutionException {
|
||||
return this.delegate.get();
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Future
|
||||
public T get(long j, TimeUnit timeUnit) throws InterruptedException, ExecutionException, TimeoutException {
|
||||
return this.delegate.get(j, timeUnit);
|
||||
}
|
||||
|
||||
@Override // com.google.common.util.concurrent.ListenableFuture
|
||||
public void addListener(Runnable runnable, Executor executor) {
|
||||
this.delegate.addListener(runnable, executor);
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return this.delegate.toString();
|
||||
}
|
||||
}
|
||||
|
||||
public static final class Completer<T> {
|
||||
private boolean attemptedSetting;
|
||||
private ResolvableFuture<Void> cancellationFuture = ResolvableFuture.create();
|
||||
SafeFuture<T> future;
|
||||
Object tag;
|
||||
|
||||
private void setCompletedNormally() {
|
||||
this.tag = null;
|
||||
this.future = null;
|
||||
this.cancellationFuture = null;
|
||||
}
|
||||
|
||||
Completer() {
|
||||
}
|
||||
|
||||
public boolean set(T t) {
|
||||
this.attemptedSetting = true;
|
||||
SafeFuture<T> safeFuture = this.future;
|
||||
boolean z = safeFuture != null && safeFuture.set(t);
|
||||
if (z) {
|
||||
setCompletedNormally();
|
||||
}
|
||||
return z;
|
||||
}
|
||||
|
||||
public boolean setException(Throwable th) {
|
||||
this.attemptedSetting = true;
|
||||
SafeFuture<T> safeFuture = this.future;
|
||||
boolean z = safeFuture != null && safeFuture.setException(th);
|
||||
if (z) {
|
||||
setCompletedNormally();
|
||||
}
|
||||
return z;
|
||||
}
|
||||
|
||||
public boolean setCancelled() {
|
||||
this.attemptedSetting = true;
|
||||
SafeFuture<T> safeFuture = this.future;
|
||||
boolean z = safeFuture != null && safeFuture.cancelWithoutNotifyingCompleter(true);
|
||||
if (z) {
|
||||
setCompletedNormally();
|
||||
}
|
||||
return z;
|
||||
}
|
||||
|
||||
public void addCancellationListener(Runnable runnable, Executor executor) {
|
||||
ResolvableFuture<Void> resolvableFuture = this.cancellationFuture;
|
||||
if (resolvableFuture != null) {
|
||||
resolvableFuture.addListener(runnable, executor);
|
||||
}
|
||||
}
|
||||
|
||||
void fireCancellationListeners() {
|
||||
this.tag = null;
|
||||
this.future = null;
|
||||
this.cancellationFuture.set(null);
|
||||
}
|
||||
|
||||
protected void finalize() {
|
||||
ResolvableFuture<Void> resolvableFuture;
|
||||
SafeFuture<T> safeFuture = this.future;
|
||||
if (safeFuture != null && !safeFuture.isDone()) {
|
||||
safeFuture.setException(new FutureGarbageCollectedException("The completer object was garbage collected - this future would otherwise never complete. The tag was: " + this.tag));
|
||||
}
|
||||
if (this.attemptedSetting || (resolvableFuture = this.cancellationFuture) == null) {
|
||||
return;
|
||||
}
|
||||
resolvableFuture.set(null);
|
||||
}
|
||||
}
|
||||
|
||||
static final class FutureGarbageCollectedException extends Throwable {
|
||||
FutureGarbageCollectedException(String str) {
|
||||
super(str);
|
||||
}
|
||||
|
||||
@Override // java.lang.Throwable
|
||||
public synchronized Throwable fillInStackTrace() {
|
||||
return this;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,18 @@
|
||||
package androidx.concurrent.futures;
|
||||
|
||||
import java.util.concurrent.Executor;
|
||||
|
||||
/* loaded from: classes.dex */
|
||||
public enum DirectExecutor implements Executor {
|
||||
INSTANCE;
|
||||
|
||||
@Override // java.lang.Enum
|
||||
public String toString() {
|
||||
return "DirectExecutor";
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Executor
|
||||
public void execute(Runnable runnable) {
|
||||
runnable.run();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,28 @@
|
||||
package androidx.concurrent.futures;
|
||||
|
||||
import com.google.common.util.concurrent.ListenableFuture;
|
||||
|
||||
/* loaded from: classes.dex */
|
||||
public final class ResolvableFuture<V> extends AbstractResolvableFuture<V> {
|
||||
public static <V> ResolvableFuture<V> create() {
|
||||
return new ResolvableFuture<>();
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture
|
||||
public boolean set(V v) {
|
||||
return super.set(v);
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture
|
||||
public boolean setException(Throwable th) {
|
||||
return super.setException(th);
|
||||
}
|
||||
|
||||
@Override // androidx.concurrent.futures.AbstractResolvableFuture
|
||||
public boolean setFuture(ListenableFuture<? extends V> listenableFuture) {
|
||||
return super.setFuture(listenableFuture);
|
||||
}
|
||||
|
||||
private ResolvableFuture() {
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user