安卓开发中遇到的奇奇怪怪的问题 (3)

FinalizerWatchdogDaemon
java.util.concurrent.TimeoutException
android.os.BinderProxy.finalize() timed out after 120 seconds
android.os.BinderProxy.destroy(Native Method)
android.os.BinderProxy.finalize(Binder.java:547)
java.lang.Daemons$FinalizerDaemon.doFinalize(Daemons.java:214)
java.lang.Daemons$FinalizerDaemon.run(Daemons.java:193)
java.lang.Thread.run(Thread.java:818)

try {
    final Class clazz = Class.forName("java.lang.Daemons$FinalizerWatchdogDaemon");
    final Field field = clazz.getDeclaredField("INSTANCE");
    field.setAccessible(true);
    final Object watchdog = field.get(null);
    try {
        final Field thread = clazz.getSuperclass().getDeclaredField("thread");
        thread.setAccessible(true);
        thread.set(watchdog, null);
    } catch (final Throwable t) {
        Log.e(TAG, "stopWatchDog, set null occur error:" + t);

        t.printStackTrace();
        try {
            // 直接调用stop方法，在Android 6.0之前会有线程安全问题
            final Method method = clazz.getSuperclass().getDeclaredMethod("stop");
            method.setAccessible(true);
            method.invoke(watchdog);
        } catch (final Throwable e) {
            Log.e(TAG, "stopWatchDog, stop occur error:" + t);
            t.printStackTrace();
        }
    }
} catch (final Throwable t) {
    Log.e(TAG, "stopWatchDog, get object occur error:" + t);
    t.printStackTrace();
}

public static void fix() {
    try {
        Class clazz = Class.forName("java.lang.Daemons$FinalizerWatchdogDaemon");

        Method method = clazz.getSuperclass().getDeclaredMethod("stop");
        method.setAccessible(true);

        Field field = clazz.getDeclaredField("INSTANCE");
        field.setAccessible(true);

        method.invoke(field.get(null));

    }
    catch (Throwable e) {
        e.printStackTrace();
    }
}

private static abstract class Daemon implements Runnable {

    private Thread thread;// 一种是直接置空thread

    public synchronized void start() {
        if (thread != null) {
            throw new IllegalStateException("already running");
        }
        thread = new Thread(ThreadGroup.systemThreadGroup, this, getClass().getSimpleName());
        thread.setDaemon(true);
        thread.start();
    }

    public abstract void run();

    protected synchronized boolean isRunning() {
        return thread != null;
    }

    public synchronized void interrupt() {
        if (thread == null) {
            throw new IllegalStateException("not running");
        }
        thread.interrupt();
    }

    public void stop() {
        Thread threadToStop;
        synchronized (this) {
            threadToStop = thread;
            thread = null; // 一种是通过调用stop置空thread
        }
        if (threadToStop == null) {
            throw new IllegalStateException("not running");
        }
        threadToStop.interrupt();
        while (true) {
            try {
                threadToStop.join();
                return;
            } catch (InterruptedException ignored) {
            }
        }
    }

    public synchronized StackTraceElement[] getStackTrace() {
        return thread != null ? thread.getStackTrace() : EmptyArray.STACK_TRACE_ELEMENT;
    }
}

public synchronized void interrupt(Thread thread) {
     if (thread == null) {
         throw new IllegalStateException("not running");
     }
     thread.interrupt();       
}

static void tryStart(boolean purgeEnabled) {
    if (purgeEnabled) {
        for (;;) { // 一个死循环
            ScheduledExecutorService curr = PURGE_THREAD.get();
            if (curr != null) {
                return;
            }
            ScheduledExecutorService next = Executors.newScheduledThreadPool(1, new RxThreadFactory("RxSchedulerPurge"));
            if (PURGE_THREAD.compareAndSet(curr, next)) {

        // RxSchedulerPurge线程池，每隔1s清除一次
                next.scheduleAtFixedRate(new ScheduledTask(), PURGE_PERIOD_SECONDS, PURGE_PERIOD_SECONDS, TimeUnit.SECONDS);

                return;
            } else {
                next.shutdownNow();
            }
        }
    }
}

static final class ScheduledTask implements Runnable {
    @Override
    public void run() {
        for (ScheduledThreadPoolExecutor e : new ArrayList<ScheduledThreadPoolExecutor>(POOLS.keySet())) {
            if (e.isShutdown()) {
                POOLS.remove(e); 
            } else {
                e.purge();//图中154行，purge方法可用于移除那些已被取消的Future。
            }
        }
    }
}

 // 修改周期时间为一小时
 System.setProperty("rx2.purge-period-seconds", "3600");

 System.setProperty("rx2.purge-enabled", false);

static final class PurgeProperties {

        boolean purgeEnable;

        int purgePeriod;

        void load(Properties properties) {
            if (properties.containsKey(PURGE_ENABLED_KEY)) {
                purgeEnable = Boolean.parseBoolean(properties.getProperty(PURGE_ENABLED_KEY));
            } else {
                purgeEnable = true; // 默认是true
            }

            if (purgeEnable && properties.containsKey(PURGE_PERIOD_SECONDS_KEY)) {
                try {
                    // 可以修改周期时间
                    purgePeriod = Integer.parseInt(properties.getProperty(PURGE_PERIOD_SECONDS_KEY));
                } catch (NumberFormatException ex) {
                    purgePeriod = 1; // 默认是1s
                }
            } else {
                purgePeriod = 1; // 默认是1s
            }
        }
    }

java.lang.IllegalStateException：
Not allowed to start service Intent { xxx.MyService }: 
app is in background uid null