下面部分寫的比較零散，整合了一下，可以移步到最新一篇：

通常情況下，Android系統開機保持在20s~25s應該算是合格比較好的狀態。

最近幾天在看關於Android系統開機啟動過程的相關內容。做個筆記。

關於有話Android系統開機時間有話，採取三個措施有話，修改ZygoteInit.java。 Android系統開機啟動過程這裡就不說了，網上很多大牛對應的文章。

1. 修改ZygoteInit.java 中預載入資源函式preload() ,  preloadClasses(); 與 preloadResources(); 並行載入。
2. 修改讀取配置資訊過程中GC頻率。
3. 提升程序優先順序。
 

1. 

    static void preload() {
        //
        Thread  preloadRsThread = new Thread(new Runnable(){

            @Override
            public void run() {
                // TODO Auto-generated method stub
            //將該資源載入放在子執行緒中  。載入資原始檔要比載入classes檔案要快，因此這裡不提升子執行緒優先順序。  
            preloadResources();
            }

        }) ;

        preloadRsThread.start() ;
        preloadClasses();
        //wait preloadRes complete.
        try {
            preloadRsThread.join() ;
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
       
        //暴露什麼問題。
        preloadOpenGL();
    }
 

/**
     * Performs Zygote process initialization. Loads and initializes
     * commonly used classes.
     *
     * Most classes only cause a few hundred bytes to be allocated, but
     * a few will allocate a dozen Kbytes (in one case, 500+K).
     */
    private static void preloadClasses() {
        final VMRuntime runtime = VMRuntime.getRuntime();

        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream(
                PRELOADED_CLASSES);
        if (is == null) {
            Log.e(TAG, "Couldn't find " + PRELOADED_CLASSES + ".");
        } else {
            Log.i(TAG, "Preloading classes...");
            long startTime = SystemClock.uptimeMillis();

            // Drop root perms while running static initializers.
            setEffectiveGroup(UNPRIVILEGED_GID);
            setEffectiveUser(UNPRIVILEGED_UID);

            // Alter the target heap utilization.  With explicit GCs this
            // is not likely to have any effect.
            float defaultUtilization = runtime.getTargetHeapUtilization();
            runtime.setTargetHeapUtilization(0.8f);

            // Start with a clean slate.
            System.gc();
            runtime.runFinalizationSync();
            Debug.startAllocCounting();

            try {
                BufferedReader br
                    = new BufferedReader(new InputStreamReader(is), 256);

                int count = 0;
                String line;
                while ((line = br.readLine()) != null) {
                    // Skip comments and blank lines.
                    line = line.trim();
                    if (line.startsWith("#") || line.equals("")) {
                        continue;
                    }

                    try {
                        if (false) {
                            Log.v(TAG, "Preloading " + line + "...");
                        }
                        Class.forName(line);
                        //減少GC頻率，modify   begin
                        if (count%128==0&&Debug.getGlobalAllocSize() > PRELOAD_GC_THRESHOLD) {//end
                            if (false) {
                                Log.v(TAG,
                                    " GC at " + Debug.getGlobalAllocSize());
                            }
                            System.gc();
                            runtime.runFinalizationSync();
                            Debug.resetGlobalAllocSize();
                        }
                        count++;
                    } catch (ClassNotFoundException e) {
                        Log.w(TAG, "Class not found for preloading: " + line);
                    } catch (UnsatisfiedLinkError e) {
                        Log.w(TAG, "Problem preloading " + line + ": " + e);
                    } catch (Throwable t) {
                        Log.e(TAG, "Error preloading " + line + ".", t);
                        if (t instanceof Error) {
                            throw (Error) t;
                        }
                        if (t instanceof RuntimeException) {
                            throw (RuntimeException) t;
                        }
                        throw new RuntimeException(t);
                    }
                }

                Log.i(TAG, "...preloaded " + count + " classes in "
                        + (SystemClock.uptimeMillis()-startTime) + "ms.");
            } catch (IOException e) {
                Log.e(TAG, "Error reading " + PRELOADED_CLASSES + ".", e);
            } finally {
                IoUtils.closeQuietly(is);
                // Restore default.
                runtime.setTargetHeapUtilization(defaultUtilization);

                // Fill in dex caches with classes, fields, and methods brought in by preloading.
                runtime.preloadDexCaches();

                Debug.stopAllocCounting();

                // Bring back root. We'll need it later.
                setEffectiveUser(ROOT_UID);
                setEffectiveGroup(ROOT_GID);
            }
        }
    }
 

//    ZygoteInit.java入口
    public static void main(String argv[]) {
        try {

            //優化開機速度 begin
            /* 20150127 begin */
            //獲取當前程序優先順序
            int currentPriority = Process.getThreadPriority(Process.myPid()) ;
            //提升當前程序優先順序。
            Process.setThreadPriority(Process.THREAD_PRIORITY_AUDIO) ;
            /* 20150127 end */
            
            // Start profiling the zygote initialization.
            SamplingProfilerIntegration.start();

//            1.註冊socket服務端
            registerZygoteSocket();
            EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
                SystemClock.uptimeMillis());
//            5.載入資源
            preload();
            EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
                SystemClock.uptimeMillis());

            // Finish profiling the zygote initialization.
            SamplingProfilerIntegration.writeZygoteSnapshot();

            // Do an initial gc to clean up after startup
            gc();
            
            /* 20150127 begin */
            Process.setThreadPriority(currentPriority) ;
            /* 20150127 end */
            //優化開機速度 end
            // Disable tracing so that forked processes do not inherit stale tracing tags from
            // Zygote.
            Trace.setTracingEnabled(false);

            // If requested, start system server directly from Zygote
            if (argv.length != 2) {
                throw new RuntimeException(argv[0] + USAGE_STRING);
            }
//          2. 呼叫starySystemServer（）方法
            if (argv[1].equals("start-system-server")) {
                startSystemServer();
            } else if (!argv[1].equals("")) {
                throw new RuntimeException(argv[0] + USAGE_STRING);
            }

            Log.i(TAG, "Accepting command socket connections");

            //3.迴圈監聽並接收客戶端請求。
            runSelectLoop();
//關閉socket
            closeServerSocket();
        } catch (MethodAndArgsCaller caller) {
//          4  《深入理解Android卷1》作者說這裡比較重要
            caller.run();
        } catch (RuntimeException ex) {
            Log.e(TAG, "Zygote died with exception", ex);
            closeServerSocket();
            throw ex;
        }
    }

   /** when preloading, GC after allocating this many bytes 
     * 
     * 20150127 優化開機速度
     */
    
    //- private static final int PRELOAD_GC_THRESHOLD = 50000;
    private static final int PRELOAD_GC_THRESHOLD = 64*1024*1024;
    
    /*20150127 優化開機速度 end*/

另外，Android系統啟動過程中，會預先載入資原始檔，這些檔案中，包含了很多系統應用會頻繁使用到的資原始檔，比如圖片資源等。因此，我們自己的新新增其他的部分資源也可以預先載入到記憶體，

這樣不僅提升響應速度，而且也可以加快應用的冷啟動速度。

Android系統性能優化是個大工程，從一個小小的細節出發，或許能收穫哪怕幾百毫秒的時間，也是不錯的。細節決定成敗。

關於程序優先順序：

		Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); //設定執行緒優先順序為後臺，這樣當多個執行緒併發後很多無關緊要的執行緒分配的CPU時間將會減少，有利於主執行緒的處理，有以下幾種:
		int THREAD_PRIORITY_AUDIO ;//標準音樂播放使用的執行緒優先順序
		int THREAD_PRIORITY_BACKGROUND ;//標準後臺程式
		int THREAD_PRIORITY_DEFAULT ;// 預設應用的優先順序
		int THREAD_PRIORITY_DISPLAY ;//標準顯示系統優先順序，主要是改善UI的重新整理
		int THREAD_PRIORITY_FOREGROUND ; //標準前臺執行緒優先順序
		int THREAD_PRIORITY_LESS_FAVORABLE ;//低於favorable
		int THREAD_PRIORITY_LOWEST  ;//有效的執行緒最低的優先順序
		int THREAD_PRIORITY_MORE_FAVORABLE ; //高於favorable
		int THREAD_PRIORITY_URGENT_AUDIO  ;//標準較重要音訊播放優先順序
		int THREAD_PRIORITY_URGENT_DISPLAY  ;//標準較重要顯示優先順序，對於輸入事件同樣適用。

Android系統開機優化，可以修改的地方還有很多。後續會補上。

此外，Android開機過程中，PackageManagerService會掃描系統內建apk，因此這個過程也是耗費時間比較長的。

在這個過程中下功夫還是很有必要。

比如odex優化等。