package defpackage;

import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;

/* renamed from: ᵮʽᵺ, reason: contains not printable characters */
/* loaded from: classes3.dex */
public abstract class AbstractRunnableC4177 extends AtomicReference implements Runnable {

    /* renamed from: ᵢˇᵭ, reason: contains not printable characters */
    public static final RunnableC0226 f15610;

    /* renamed from: ᵧᵾˀˈ, reason: contains not printable characters */
    public static final RunnableC0226 f15611;

    static {
        int i = 3;
        f15611 = new RunnableC0226(i);
        f15610 = new RunnableC0226(i);
    }

    @Override // java.lang.Runnable
    public final void run() {
        Thread threadCurrentThread = Thread.currentThread();
        Object objMo1690 = null;
        if (compareAndSet(null, threadCurrentThread)) {
            boolean zMo1694 = mo1694();
            RunnableC0226 runnableC0226 = f15611;
            if (!zMo1694) {
                try {
                    objMo1690 = mo1690();
                } catch (Throwable th) {
                    try {
                        if (th instanceof InterruptedException) {
                            Thread.currentThread().interrupt();
                        }
                        if (!compareAndSet(threadCurrentThread, runnableC0226)) {
                            m9096(threadCurrentThread);
                        }
                        if (zMo1694) {
                            return;
                        }
                        mo1692(th);
                        return;
                    } finally {
                        if (!compareAndSet(threadCurrentThread, runnableC0226)) {
                            m9096(threadCurrentThread);
                        }
                        if (!zMo1694) {
                            mo1693(null);
                        }
                    }
                }
            }
        }
    }

    @Override // java.util.concurrent.atomic.AtomicReference
    public final String toString() {
        String str;
        Runnable runnable = (Runnable) get();
        if (runnable == f15611) {
            str = "running=[DONE]";
        } else if (runnable instanceof RunnableC0521) {
            str = "running=[INTERRUPTED]";
        } else if (runnable instanceof Thread) {
            str = "running=[RUNNING ON " + ((Thread) runnable).getName() + "]";
        } else {
            str = "running=[NOT STARTED YET]";
        }
        return str + ", " + mo1691();
    }

    /* renamed from: ˇʼʤˎ */
    public abstract Object mo1690();

    /* renamed from: ˎˏʜʾ, reason: contains not printable characters */
    public final void m9096(Thread thread) {
        Runnable runnable = (Runnable) get();
        RunnableC0521 runnableC0521 = null;
        boolean z = false;
        int i = 0;
        while (true) {
            boolean z2 = runnable instanceof RunnableC0521;
            RunnableC0226 runnableC0226 = f15610;
            if (!z2 && runnable != runnableC0226) {
                break;
            }
            if (z2) {
                runnableC0521 = (RunnableC0521) runnable;
            }
            i++;
            if (i <= 1000) {
                Thread.yield();
            } else if (runnable == runnableC0226 || compareAndSet(runnable, runnableC0226)) {
                z = Thread.interrupted() || z;
                LockSupport.park(runnableC0521);
            }
            runnable = (Runnable) get();
        }
        if (z) {
            thread.interrupt();
        }
    }

    /* renamed from: ˏˋٴ */
    public abstract String mo1691();

    /* renamed from: ˏᵙ, reason: contains not printable characters */
    public final void m9097() {
        RunnableC0226 runnableC0226 = f15610;
        RunnableC0226 runnableC02262 = f15611;
        Runnable runnable = (Runnable) get();
        if (runnable instanceof Thread) {
            RunnableC0521 runnableC0521 = new RunnableC0521(this);
            RunnableC0521.m2234(runnableC0521, Thread.currentThread());
            if (compareAndSet(runnable, runnableC0521)) {
                try {
                    ((Thread) runnable).interrupt();
                } finally {
                    if (((Runnable) getAndSet(runnableC02262)) == runnableC0226) {
                        LockSupport.unpark((Thread) runnable);
                    }
                }
            }
        }
    }

    /* renamed from: ᵥᵯˎ */
    public abstract void mo1692(Throwable th);

    /* renamed from: ᵴᵳ */
    public abstract void mo1693(Object obj);

    /* renamed from: ᵻᵢﹳᵰ */
    public abstract boolean mo1694();
}