Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/google/android/gms/internal/ads/zzgcp.java

@@ -0,0 +1,124 @@
+package com.google.android.gms.internal.ads;
+
+import com.ironsource.v8;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.LockSupport;
+
+/* loaded from: classes3.dex */
+abstract class zzgcp extends AtomicReference implements Runnable {
+    private static final Runnable zza = new zzgcn(null);
+    private static final Runnable zzb = new zzgcn(null);
+
+    private final void zzc(Thread thread) {
+        Runnable runnable = (Runnable) get();
+        zzgcm zzgcmVar = null;
+        boolean z = false;
+        int i = 0;
+        while (true) {
+            if (!(runnable instanceof zzgcm)) {
+                if (runnable != zzb) {
+                    break;
+                }
+            } else {
+                zzgcmVar = (zzgcm) runnable;
+            }
+            i++;
+            if (i > 1000) {
+                Runnable runnable2 = zzb;
+                if (runnable == runnable2 || compareAndSet(runnable, runnable2)) {
+                    z = Thread.interrupted() || z;
+                    LockSupport.park(zzgcmVar);
+                }
+            } else {
+                Thread.yield();
+            }
+            runnable = (Runnable) get();
+        }
+        if (z) {
+            thread.interrupt();
+        }
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        Thread currentThread = Thread.currentThread();
+        Object obj = null;
+        if (compareAndSet(null, currentThread)) {
+            boolean z = !zzg();
+            if (z) {
+                try {
+                    obj = zza();
+                } catch (Throwable th) {
+                    try {
+                        zzgda.zza(th);
+                        if (!compareAndSet(currentThread, zza)) {
+                            zzc(currentThread);
+                        }
+                        zzd(th);
+                        return;
+                    } catch (Throwable th2) {
+                        if (!compareAndSet(currentThread, zza)) {
+                            zzc(currentThread);
+                        }
+                        zze(null);
+                        throw th2;
+                    }
+                }
+            }
+            if (!compareAndSet(currentThread, zza)) {
+                zzc(currentThread);
+            }
+            if (z) {
+                zze(obj);
+            }
+        }
+    }
+
+    @Override // java.util.concurrent.atomic.AtomicReference
+    public final String toString() {
+        String str;
+        Runnable runnable = (Runnable) get();
+        if (runnable == zza) {
+            str = "running=[DONE]";
+        } else if (runnable instanceof zzgcm) {
+            str = "running=[INTERRUPTED]";
+        } else if (runnable instanceof Thread) {
+            str = "running=[RUNNING ON " + ((Thread) runnable).getName() + v8.i.e;
+        } else {
+            str = "running=[NOT STARTED YET]";
+        }
+        return str + ", " + zzb();
+    }
+
+    public abstract Object zza() throws Exception;
+
+    public abstract String zzb();
+
+    public abstract void zzd(Throwable th);
+
+    public abstract void zze(Object obj);
+
+    public abstract boolean zzg();
+
+    public final void zzh() {
+        Runnable runnable = (Runnable) get();
+        if (runnable instanceof Thread) {
+            zzgcm zzgcmVar = new zzgcm(this, null);
+            super/*java.util.concurrent.locks.AbstractOwnableSynchronizer*/.setExclusiveOwnerThread(Thread.currentThread());
+            if (compareAndSet(runnable, zzgcmVar)) {
+                try {
+                    Thread thread = (Thread) runnable;
+                    thread.interrupt();
+                    if (((Runnable) getAndSet(zza)) == zzb) {
+                        LockSupport.unpark(thread);
+                    }
+                } catch (Throwable th) {
+                    if (((Runnable) getAndSet(zza)) == zzb) {
+                        LockSupport.unpark((Thread) runnable);
+                    }
+                    throw th;
+                }
+            }
+        }
+    }
+}