基于Java实现的小熊播放器设计源码

package com.player.smallBear.utils; import android.os.Handler; import android.os.Looper; import android.util.Log; import androidx.annotation.CallSuper; import androidx.annotation.IntRange; import androidx.annotation.NonNull; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Timer; import java.util.TimerTask; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CountDownLatch; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.RejectedExecutionException; import java.util.concurrent.ThreadFactory; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; /** * <pre> * author: Blankj * blog : http://blankj.com * time : 2018/05/08 * desc : utils about thread * </pre> */ public final class ThreadUtils { private static final Handler HANDLER = new Handler(Looper.getMainLooper()); private static final Map<Integer, Map<Integer, ExecutorService>> TYPE_PRIORITY_POOLS = new HashMap<>(); private static final Map<Task, ExecutorService> TASK_POOL_MAP = new ConcurrentHashMap<>(); private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors(); private static final Timer TIMER = new Timer(); private static final byte TYPE_SINGLE = -1; private static final byte TYPE_CACHED = -2; private static final byte TYPE_IO = -4; private static final byte TYPE_CPU = -8; private static Executor sDeliver; /** * Return whether the thread is the main thread. * * @return {@code true}: yes<br>{@code false}: no */ public static boolean isMainThread() { return Looper.myLooper() == Looper.getMainLooper(); } public static Handler getMainHandler() { return HANDLER; } public static void runOnUiThread(final Runnable runnable) { if (Looper.myLooper() == Looper.getMainLooper()) { runnable.run(); } else { HANDLER.post(runnable); } } public static void runOnUiThreadDelayed(final Runnable runnable, long delayMillis) { HANDLER.postDelayed(runnable, delayMillis); } /** * Return a thread pool that reuses a fixed number of threads * operating off a shared unbounded queue, using the provided * ThreadFactory to create new threads when needed. * * @param size The size of thread in the pool. * @return a fixed thread pool */ public static ExecutorService getFixedPool(@IntRange(from = 1) final int size) { return getPoolByTypeAndPriority(size); } /** * Return a thread pool that reuses a fixed number of threads * operating off a shared unbounded queue, using the provided * ThreadFactory to create new threads when needed. * * @param size The size of thread in the pool. * @param priority The priority of thread in the poll. * @return a fixed thread pool */ public static ExecutorService getFixedPool(@IntRange(from = 1) final int size, @IntRange(from = 1, to = 10) final int priority) { return getPoolByTypeAndPriority(size, priority); } /** * Return a thread pool that uses a single worker thread operating * off an unbounded queue, and uses the provided ThreadFactory to * create a new thread when needed. * * @return a single thread pool */ public static ExecutorService getSinglePool() { return getPoolByTypeAndPriority(TYPE_SINGLE); } /** * Return a thread pool that uses a single worker thread operating * off an unbounded queue, and uses the provided ThreadFactory to * create a new thread when needed. * * @param priority The priority of thread in the poll. * @return a single thread pool */ public static ExecutorService getSinglePool(@IntRange(from = 1, to = 10) final int priority) { return getPoolByTypeAndPriority(TYPE_SINGLE, priority); } /** * Return a thread pool that creates new threads as needed, but * will reuse previously constructed threads when they are * available. * * @return a cached thread pool */ public static ExecutorService getCachedPool() { return getPoolByTypeAndPriority(TYPE_CACHED); } /** * Return a thread pool that creates new threads as needed, but * will reuse previously constructed threads when they are * available. * * @param priority The priority of thread in the poll. * @return a cached thread pool */ public static ExecutorService getCachedPool(@IntRange(from = 1, to = 10) final int priority) { return getPoolByTypeAndPriority(TYPE_CACHED, priority); } /** * Return a thread pool that creates (2 * CPU_COUNT + 1) threads * operating off a queue which size is 128. * * @return a IO thread pool */ public static ExecutorService getIoPool() { return getPoolByTypeAndPriority(TYPE_IO); } /** * Return a thread pool that creates (2 * CPU_COUNT + 1) threads * operating off a queue which size is 128. * * @param priority The priority of thread in the poll. * @return a IO thread pool */ public static ExecutorService getIoPool(@IntRange(from = 1, to = 10) final int priority) { return getPoolByTypeAndPriority(TYPE_IO, priority); } /** * Return a thread pool that creates (CPU_COUNT + 1) threads * operating off a queue which size is 128 and the maximum * number of threads equals (2 * CPU_COUNT + 1). * * @return a cpu thread pool for */ public static ExecutorService getCpuPool() { return getPoolByTypeAndPriority(TYPE_CPU); } /** * Return a thread pool that creates (CPU_COUNT + 1) threads * operating off a queue which size is 128 and the maximum * number of threads equals (2 * CPU_COUNT + 1). * * @param priority The priority of thread in the poll. * @return a cpu thread pool for */ public static ExecutorService getCpuPool(@IntRange(from = 1, to = 10) final int priority) { return getPoolByTypeAndPriority(TYPE_CPU, priority); } /** * Executes the given task in a fixed thread pool. * * @param size The size of thread in the fixed thread pool. * @param task The task to execute. * @param <T> The type of the task's result. */ public static <T> void executeByFixed(@IntRange(from = 1) final int size, final Task<T> task) { execute(getPoolByTypeAndPriority(size), task); } /** * Executes the given task in a fixed thread pool. * * @param size The size of thread in the fixed thread pool. * @param task The task to execute. * @param priority The priority of thread in the poll. * @param <T> The type of the task's result. */ public static <T> void executeByFixed(@IntRange(from = 1) final int size, final Task<T> task, @IntRange(from = 1, to = 10) final int priority) { execute(getPoolByTypeAndPriority(size, priority), task); } /** * Executes the given task in a fixed thread pool after the given delay. * * @param size The size of thread in the fixed thread pool. * @param task The task to execute. * @param delay The time from now to delay execution. * @param unit The time unit of the delay parameter. * @param <T> The type of the task's result. */ public static <T> void executeByFixedWithDelay(@IntRange(from = 1) final int size,