package com.bytedance.sdk.component;

import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import androidx.annotation.GuardedBy;
import com.bytedance.sdk.component.ro;
import java.util.Iterator;
import java.util.LinkedList;

/* JADX INFO: loaded from: classes.dex */
public class lb {

    @GuardedBy("sLock")
    private static volatile Handler ro;
    private static final Object fm = new Object();

    /* JADX INFO: renamed from: lb, reason: collision with root package name */
    @GuardedBy("sLock")
    private static final LinkedList<Runnable> f6654lb = new LinkedList<>();
    private static Object yz = new Object();

    public static class fm extends Handler {
        public fm(Looper looper) {
            super(looper);
        }

        @Override // android.os.Handler
        public void handleMessage(Message message) {
            if (message.what == 1) {
                try {
                    lb.lb();
                } catch (OutOfMemoryError unused) {
                }
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void lb() {
        LinkedList linkedList;
        synchronized (yz) {
            try {
                synchronized (fm) {
                    LinkedList<Runnable> linkedList2 = f6654lb;
                    linkedList = (LinkedList) linkedList2.clone();
                    linkedList2.clear();
                    ro().removeMessages(1);
                }
                if (linkedList.size() > 0) {
                    Iterator it = linkedList.iterator();
                    while (it.hasNext()) {
                        ((Runnable) it.next()).run();
                    }
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    private static Handler ro() {
        Handler handler;
        if (ro != null) {
            return ro;
        }
        synchronized (fm) {
            try {
                if (ro == null) {
                    ro.fm fmVar = ro.fm;
                    HandlerThread handlerThreadFm = fmVar != null ? fmVar.fm("queued-work-looper", -2) : null;
                    if (handlerThreadFm == null) {
                        handlerThreadFm = new HandlerThread("queued-work-looper", -2);
                        handlerThreadFm.start();
                    }
                    ro = new fm(handlerThreadFm.getLooper());
                }
                handler = ro;
            } catch (Throwable th) {
                throw th;
            }
        }
        return handler;
    }

    public static void fm(Runnable runnable, boolean z10) {
        try {
            Handler handlerRo = ro();
            synchronized (fm) {
                try {
                    f6654lb.add(runnable);
                    if (z10) {
                        handlerRo.sendEmptyMessageDelayed(1, 100L);
                    } else {
                        handlerRo.sendEmptyMessage(1);
                    }
                } finally {
                }
            }
        } catch (OutOfMemoryError unused) {
        }
    }
}