在開始文章之前，強烈建議不熟悉MultiDex坑點的童鞋看兩篇文章：

簡單來說，安裝完成並初次啟動APP的時候，5.0以下某些低端機會出現ANR或者長時間卡頓不進入引導頁，而罪魁禍首是MultiDex.install(Context context)的dexopt過程耗時過長。因此需要在初次啟動時做特別處理。

以上兩篇文章都提供瞭解決這個問題的思路以及詳細解釋，大致分為3步：

1. 在Application.attachBaseContext(Context base)中，判斷是否初次啟動，以及系統版本是否小於5.0，如果是，跳到2；否則，直接執行MultiDex.install(Context context)
   。
2. 開啟一個新程序，在這個程序中執行MultiDex.install(Context context)。執行完畢，喚醒主程序，自身結束。主程序在開啟新程序後，自身是掛起的，直到被喚醒。
3. 喚醒的主程序繼續執行初始化操作。

這個解決思路對現有程式碼幾乎是沒有改動的，並且簡單粗暴：既然不能直接呼叫MultiDex.install(Context context)，那麼幹脆開啟新程序呼叫，因為開啟新程序時，主程序已經成為後臺程序，即使掛起也不會ANR。
開啟新程序載入太麻煩，能不能開新執行緒載入，而主執行緒繼續Application初始化？顯然不行。因為multidex安裝沒有結束，意味著dex還沒載入進來，某些類強行使用就會報NoClassDefFoundError

有一個小難點是：主程序如何得知載入程序完成載入？第一篇文章的思路是，載入程序建立的同時，建立一個臨時檔案，結束載入退出前，刪除這個檔案。主程序輪詢訪問檔案的存在性即可。第二篇文章使用MODE_MULTI_PROCESS標記使得SharedPreference得以程序間共享，主程序輪詢sp檔案即可。但是，這個標記在6.0被廢除，Google不保證行為的準確性。而且……我們有一萬個理由，能不寫輪詢就不寫。

下面是使用Messenger的實現：

BaseApplication.class

public abstract class BaseApplication extends Application
 
{

    @SuppressWarnings("MismatchedReadAndWriteOfArray")
    private static final byte[] lock = new byte[0];

    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(base);
        //Android 5.0以上不需要特別處理
        if (!isAsyncLaunchProcess() && Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            if (needWait(base)) {
                /*
                    第一次啟動APP由於MultiDex將會非常緩慢，某些低端機可能ANR。
                    因此這裡的做法是掛起主程序，開啟:async_launch程序執行dexopt。
                    dexopt執行完畢，主程序重新變為前臺程序，繼續執行初始化。
                    主程序在這過程中變成後臺程序，因此阻塞將不會引起ANR。
                 */
                DexInstallDeamonThread thread = new DexInstallDeamonThread(this, base);
                thread.start();

                //阻塞等待:async_launch完成載入
                synchronized (lock) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                thread.exit();
                Log.d("BaseApplication", "dexopt finished. alloc MultiDex.install()");
            } else {
                MultiDex.install(this);
            }
        }
    }

    public boolean isAsyncLaunchProcess() {
        String processName = SystemUtils.getCurrentProcessName(this);
        return processName != null && processName.contains(":async_launch");
    }

    @SuppressWarnings("deprecation")
    private boolean needWait(Context context) {
        //這裡實現不唯一，讀取一個全域性的標記，判斷是否初次啟動APP
        //這個標記應當隨著版本升級而重置
        SharedPreferences sp = SPUtils.getVersionSharedPreferences(context);
        return sp.getBoolean(BaseSPKey.FIRST_LAUNCH, true);
    }

    private static class DexInstallDeamonThread extends Thread {

        private Handler handler;

        private Context application;

        private Context base;

        private Looper looper;

        public DexInstallDeamonThread(Context application, Context base) {
            this.application = application;
            this.base = base;
        }

        @SuppressLint("HandlerLeak")
        @Override
        public void run() {
            Looper.prepare();
            looper = Looper.myLooper();
            handler = new Handler() {

                @SuppressWarnings("deprecation")
                @Override
                public void handleMessage(Message msg) {
                    synchronized (lock) {
                        lock.notify();
                    }
                    SPUtils
                        .getVersionSharedPreferences(application)
                        .edit()
                        .putBoolean(BaseSPKey.FIRST_LAUNCH, false)
                        .apply();
                }
            };

            Messenger messenger = new Messenger(handler);
            Intent intent = new Intent(base, LoadResActivity.class);
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            intent.putExtra("MESSENGER", messenger);
            base.startActivity(intent);
            Looper.loop();
        }

        public void exit() {
            if (looper != null) looper.quit();
        }
    }
}

LoadResActivity.class

public class LoadResActivity extends AppCompatActivity {

    private Messenger messenger;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        super.onCreate(savedInstanceState);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        overridePendingTransition(R.anim.null_anim, R.anim.null_anim);
        setContentView(R.layout.activity_load_res);

        Log.d("LoadResActivity", "start install");
        Intent from = getIntent();
        messenger = from.getParcelableExtra("MESSENGER");

        LoadDexTask dexTask = new LoadDexTask();
        dexTask.execute();
    }

    class LoadDexTask extends AsyncTask<Void, Void, Void> {

        @Override
        protected Void doInBackground(Void... params) {
            try {
                MultiDex.install(getApplication());
                Log.d("LoadResActivity", "finish install");
                messenger.send(new Message());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void o) {
            finish();
            System.exit(0);
        }
    }

    @Override
    public void onBackPressed() {
        //無法退出
    }
}

app/AndroidManifest.xml加入：

<activity
    android:name="com.synaric.dex.LoadResActivity"
    android:launchMode= "singleTask"
    android:alwaysRetainTaskState= "false"
    android:excludeFromRecents= "true"
    android:screenOrientation= "portrait"
    android:process=":async_launch"/>

SystemUtils.class

public class SystemUtils {

    //...

    /**
     * 獲取當前程序名。
     */
    public static String getCurrentProcessName(Context context) {
        ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        if (activityManager == null) {
            return null;
        }
        for (ActivityManager.RunningAppProcessInfo processInfo : activityManager.getRunningAppProcesses()) {
            if (processInfo.pid == Process.myPid()) {
                return processInfo.processName;
            }
        }
        return null;
    }
}

最後，因為有大量程式碼在install之前執行，因此必須把程式碼中用到的類放到主dex中（需要build tool版本大於21）：

app/build.gradle

android {

    //...

    defaultConfig {
        //...

        //定義main dex中必須保留的類
        multiDexKeepProguard file('mainDexClasses.pro')
    }
}

app/mainDexClasses.pro

#這裡只是示例，需要把所有install之前用到的類寫進來

-keep public class * extends java.lang.Thread { *; }

-keep public class com.synaric.common.utils.SystemUtils { *; }

-keep public class com.synaric.common.utils.SPUtils { *; }

-keep interface android.content.SharedPreferences { *; }

-keep class android.os.Handler { *; }

-keep class com.synaric.common.BaseSPKey { *; }

-keep class android.os.Messenger { *; }

-keep class android.content.Intent { *; }