package i.a.n.g;

import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.atomic.AtomicReference;

/* JADX WARN: Unexpected interfaces in signature: [java.lang.Object] */
/* JADX INFO: compiled from: AbstractDirectTask.java */
/* JADX INFO: loaded from: classes.dex */
abstract class a extends AtomicReference<Future<?>> implements i.a.k.b {
    protected static final FutureTask<Void> e = new FutureTask<>(i.a.n.b.a.a, null);
    protected static final FutureTask<Void> f = new FutureTask<>(i.a.n.b.a.a, null);
    protected final Runnable b;
    protected Thread d;

    a(Runnable runnable) {
        this.b = runnable;
    }

    public final void a(Future<?> future) {
        Future<?> future2;
        do {
            future2 = get();
            if (future2 == e) {
                return;
            }
            if (future2 == f) {
                future.cancel(this.d != Thread.currentThread());
                return;
            }
        } while (!compareAndSet(future2, future));
    }

    @Override // i.a.k.b
    public final void dispose() {
        FutureTask<Void> futureTask;
        Future<?> future = get();
        if (future == e || future == (futureTask = f) || !compareAndSet(future, futureTask) || future == null) {
            return;
        }
        future.cancel(this.d != Thread.currentThread());
    }

    @Override // i.a.k.b
    public final boolean isDisposed() {
        Future<?> future = get();
        return future == e || future == f;
    }
}