package g.a.n2;

import java.util.WeakHashMap;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/* JADX INFO: compiled from: ExceptionsConstructor.kt */
/* JADX INFO: loaded from: classes.dex */
final class j0 extends f {
    public static final j0 a = new j0();

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    private static final ReentrantReadWriteLock f4080b = new ReentrantReadWriteLock();

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    private static final WeakHashMap<Class<? extends Throwable>, f.z.c.l<Throwable, Throwable>> f4081c = new WeakHashMap<>();

    private j0() {
    }

    @Override // g.a.n2.f
    public f.z.c.l<Throwable, Throwable> a(Class<? extends Throwable> cls) {
        ReentrantReadWriteLock.ReadLock lock = f4080b.readLock();
        lock.lock();
        try {
            f.z.c.l<Throwable, Throwable> lVar = f4081c.get(cls);
            if (lVar != null) {
                return lVar;
            }
            ReentrantReadWriteLock reentrantReadWriteLock = f4080b;
            ReentrantReadWriteLock.ReadLock lock2 = reentrantReadWriteLock.readLock();
            int i2 = 0;
            int readHoldCount = reentrantReadWriteLock.getWriteHoldCount() == 0 ? reentrantReadWriteLock.getReadHoldCount() : 0;
            for (int i3 = 0; i3 < readHoldCount; i3++) {
                lock2.unlock();
            }
            ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
            writeLock.lock();
            try {
                f.z.c.l<Throwable, Throwable> lVar2 = f4081c.get(cls);
                if (lVar2 != null) {
                    return lVar2;
                }
                f.z.c.l<Throwable, Throwable> lVarB = i.b(cls);
                f4081c.put(cls, lVarB);
                while (i2 < readHoldCount) {
                    lock2.lock();
                    i2++;
                }
                writeLock.unlock();
                return lVarB;
            } finally {
                while (i2 < readHoldCount) {
                    lock2.lock();
                    i2++;
                }
                writeLock.unlock();
            }
        } finally {
            lock.unlock();
        }
    }
}