Android Launcher-----MainThreadInitializedObject介绍

MainThreadInitializedObject 是 Android 开发中用于确保对象在主线程上初始化的一种设计模式

一、用途

MainThreadInitializedObject 通常用于确保那些需要在主线程上创建的对象（比如UI组件或依赖于主线程环境的对象）能够安全地进行初始化

二、优点

1. 可以避免多线程环境下的同步问题，因为它限定了对象的初始化必须在主线程上完成。
2. 实现了单例和懒加载，适用于那些需要访问UI组件或者依赖于应用程序上下文的单例对象，如全局配置管理器或资源管理器

三、使用

MainThreadInitializedObject 提供了一个 get(Context context) 方法，用于获取单例对象的实例。如果实例尚未创建，它将在调用线程上初始化，确保对象的创建发生在主线程上
以Launcher中的DisplayController为例：
初始化：

    public static final MainThreadInitializedObject<DisplayController> INSTANCE =
            new MainThreadInitializedObject<>(DisplayController::new);

获取对象：

    /**
     * Returns the current navigation mode
     */
    public static NavigationMode getNavigationMode(Context context) {
        return INSTANCE.get(context).getInfo().navigationMode;
    }

通过get方法获取对象

四、实现

初始化

    public MainThreadInitializedObject(ObjectProvider<T> provider) {
        mProvider = provider;
    }

初始化传入一个ObjectProvider，ObjectProvider是一个内部接口，里面只有一个get方法

    public interface ObjectProvider<T> {

        T get(Context context);
    }

获取对象

    public T get(Context context) {
        if (context instanceof SandboxContext) {
            return ((SandboxContext) context).getObject(this, mProvider);
        }

        if (mValue == null) {
            if (Looper.myLooper() == Looper.getMainLooper()) {
                mValue = TraceHelper.allowIpcs("main.thread.object",
                        () -> mProvider.get(context.getApplicationContext()));
            } else {
                try {
                    return MAIN_EXECUTOR.submit(() -> get(context)).get();
                } catch (InterruptedException|ExecutionException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        return mValue;
    }

get会先检查context对象是否属于SandboxContext，SandboxContext是一个用于管理和控制在沙盒环境中创建和销毁的对象的抽象类。它提供了对象的缓存、创建和销毁机制，确保对象的生命周期和线程安全性。

    public static abstract class SandboxContext extends ContextWrapper {

        private static final String TAG = "SandboxContext";

        protected final Set<MainThreadInitializedObject> mAllowedObjects;
        protected final Map<MainThreadInitializedObject, Object> mObjectMap = new HashMap<>();
        protected final ArrayList<Object> mOrderedObjects = new ArrayList<>();

        private final Object mDestroyLock = new Object();
        private boolean mDestroyed = false;

        public SandboxContext(Context base, MainThreadInitializedObject... allowedObjects) {
            super(base);
            mAllowedObjects = new HashSet<>(Arrays.asList(allowedObjects));
        }
        ...

        /**
         * Find a cached object from mObjectMap if we have already created one. If not, generate
         * an object using the provider.
         */
        private <T> T getObject(MainThreadInitializedObject<T> object, ObjectProvider<T> provider) {
            synchronized (mDestroyLock) {
                if (mDestroyed) {
                    Log.e(TAG, "Static object access with a destroyed context");
                }

                T t = (T) mObjectMap.get(object);
                if (t != null) {
                    return t;
                }
                if (Looper.myLooper() == Looper.getMainLooper()) {
                    t = createObject(provider);
                    // Check if we've explicitly allowed the object or if it's a SafeCloseable,
                    // it will get destroyed in onDestroy()
                    if (!mAllowedObjects.contains(object) && !(t instanceof SafeCloseable)) {
                        throw new IllegalStateException(
                                "Leaking unknown objects " + object + "  " + provider + " " + t);
                    }
                    mObjectMap.put(object, t);
                    mOrderedObjects.add(t);
                    return t;
                }
            }

            try {
                return MAIN_EXECUTOR.submit(() -> getObject(object, provider)).get();
            } catch (InterruptedException | ExecutionException e) {
                throw new RuntimeException(e);
            }
        }

        @UiThread
        protected <T> T createObject(ObjectProvider<T> provider) {
            return provider.get(this);
        }
    }

在SandboxContext和MainThreadInitializedObject中获取对象的方式相似，如果已经有了就直接获取，没有就通过MAIN_EXECUTOR在主线程上创建对象。MAIN_EXECUTOR是一个主线程的LooperExecutor，LooperExecutor继承自AbstractExecutorService，最终会在主线程执行ObjectProvider的get方法，也就是创建所需的对象，然后通过LooperExecutor的get方法获取任务执行的结果

public class LooperExecutor extends AbstractExecutorService {

    private final Handler mHandler;
    ...

    @Override
    public void execute(Runnable runnable) {
        if (getHandler().getLooper() == Looper.myLooper()) {
            runnable.run();
        } else {
            getHandler().post(runnable);
        }
    }
}

五、总结

MainThreadInitializedObject 在Android开发中扮演着重要的角色，特别是在需要确保对象在主线程上安全初始化的场景中。它提供了一种可靠的方式来管理单例对象的生命周期，同时避免了多线程环境下的潜在问题。