Android延时函数工具类

import android.os.Handler;
import android.os.Looper;

import java.util.concurrent.TimeUnit;

/**
 * KentDelay - Android专用延时工具类（简化版）
 */
public final class KentDelay {

    // 环境检测
    private static final boolean IS_MAIN_THREAD;
    private static final Handler MAIN_HANDLER;

    static {
        Looper mainLooper = Looper.getMainLooper();
        MAIN_HANDLER = new Handler(mainLooper);
        IS_MAIN_THREAD = Thread.currentThread() == mainLooper.getThread();
    }

    // ==================== 公共方法 ====================

    public static void delayMs(int millis) {
        delayMs((long) millis);
    }

    public static void delayMs(long millis) {
        validateDelayTime(millis, "milliseconds");
        if (millis == 0L) return;

        try {
            if (IS_MAIN_THREAD) {
                // 主线程用Handler
                delayOnMainThread(millis);
            } else {
                // 后台线程可以用sleep
                Thread.sleep(millis);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            android.util.Log.e("KentDelay", "delayMs error: " + e.getMessage());
        }
    }

    public static void delayNanos(long nanos) {
        validateDelayTime(nanos, "nanoseconds");
        if (nanos == 0L) return;

        if (IS_MAIN_THREAD) {
            throw new IllegalStateException("不能在主线程使用delayNanos，请用delayMs");
        }

        try {
            // 简单的纳秒延时实现
            long end = System.nanoTime() + nanos;
            while (System.nanoTime() < end) {
                if (Thread.interrupted()) {
                    throw new InterruptedException();
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public static void delayMicros(long micros) {
        validateDelayTime(micros, "microseconds");
        if (IS_MAIN_THREAD) {
            delayMs(Math.max(1L, TimeUnit.MICROSECONDS.toMillis(micros)));
        } else {
            delayNanos(TimeUnit.MICROSECONDS.toNanos(micros));
        }
    }

    public static void delaySeconds(long seconds) {
        validateDelayTime(seconds, "seconds");
        delayMs(TimeUnit.SECONDS.toMillis(seconds));
    }

    // ==================== 内部实现 ====================

    private static void delayOnMainThread(long millis) {
        final Object lock = new Object();
        final boolean[] completed = {false};

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    completed[0] = true;
                    lock.notifyAll();
                }
            }
        };

        synchronized (lock) {
            MAIN_HANDLER.postDelayed(runnable, millis);
            try {
                lock.wait(millis + 1000L); // 超时保护
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                MAIN_HANDLER.removeCallbacks(runnable);
            }
        }
    }

    private static void validateDelayTime(long time, String unit) {
        if (time < 0L) {
            throw new IllegalArgumentException("延时时间不能为负数: " + time + " " + unit);
        }
    }

    public static boolean isOnMainThread() {
        return IS_MAIN_THREAD;
    }

    private KentDelay() {
        throw new AssertionError("工具类不允许实例化");
    }
}