package io.reactivex.schedulers;

import io.reactivex.Scheduler;
import io.reactivex.internal.schedulers.ComputationScheduler;
import io.reactivex.internal.schedulers.IoScheduler;
import io.reactivex.internal.schedulers.NewThreadScheduler;
import io.reactivex.internal.schedulers.SingleScheduler;
import io.reactivex.internal.schedulers.TrampolineScheduler;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.Callable;

/* loaded from: classes2.dex */
public final class Schedulers {
    static final Scheduler a;
    static final Scheduler b;
    static final Scheduler c;
    static final Scheduler d;

    static final class ComputationHolder {
        static final Scheduler a = new ComputationScheduler();
    }

    static final class ComputationTask implements Callable<Scheduler> {
        ComputationTask() {
        }

        /* JADX WARN: Can't rename method to resolve collision */
        @Override // java.util.concurrent.Callable
        public Scheduler call() throws Exception {
            return ComputationHolder.a;
        }
    }

    static final class IOTask implements Callable<Scheduler> {
        IOTask() {
        }

        /* JADX WARN: Can't rename method to resolve collision */
        @Override // java.util.concurrent.Callable
        public Scheduler call() throws Exception {
            return IoHolder.a;
        }
    }

    static final class IoHolder {
        static final Scheduler a = new IoScheduler();
    }

    static final class NewThreadHolder {
        static final Scheduler a = new NewThreadScheduler();
    }

    static final class NewThreadTask implements Callable<Scheduler> {
        NewThreadTask() {
        }

        /* JADX WARN: Can't rename method to resolve collision */
        @Override // java.util.concurrent.Callable
        public Scheduler call() throws Exception {
            return NewThreadHolder.a;
        }
    }

    static final class SingleHolder {
        static final Scheduler a = new SingleScheduler();
    }

    static final class SingleTask implements Callable<Scheduler> {
        SingleTask() {
        }

        /* JADX WARN: Can't rename method to resolve collision */
        @Override // java.util.concurrent.Callable
        public Scheduler call() throws Exception {
            return SingleHolder.a;
        }
    }

    static {
        RxJavaPlugins.e(new SingleTask());
        a = RxJavaPlugins.b(new ComputationTask());
        b = RxJavaPlugins.c(new IOTask());
        c = TrampolineScheduler.b();
        d = RxJavaPlugins.d(new NewThreadTask());
    }

    public static Scheduler a() {
        return RxJavaPlugins.a(a);
    }

    public static Scheduler b() {
        return RxJavaPlugins.b(b);
    }

    public static Scheduler c() {
        return RxJavaPlugins.c(d);
    }

    public static Scheduler d() {
        return c;
    }
}