Zygote android что это

Русские Блоги

Анализ запуска Zygote и процесса обслуживания (Android P)

Что такое процесс зиготы

Гу Минси предположил, что Zygote означает инкубатор. В системе Android все процессы приложений и системные процессы, используемые для запуска ключевых системных служб, создаются Zygote.Это процесс инкубатора

Когда начинается процесс Zygote

Хотя процесс Zygote очень важен, на самом деле это не первый процесс системы Android

• Первым процессом системы Android является процесс init, Он запустится после загрузки ядра
• Когда процесс init запускается, он читает файл сценария init.zygote (xx) .rc в корневом каталоге, где в сценарии настраивается информация о запуске Zygote.
• Поэтому процесс Zygote запускается во время процесса запуска процесса init

Как начать процесс Zygote

Выше я узнал, что процесс Zygote запускается после того, как процесс init читает файл сценария init.zygote (xx) .rc. Теперь давайте проанализируем, что настроено в этом сценарии.

Скрипт запуска Zygote

Здесь выберите анализ init.zygote32.rc

Просто проанализируйте этот файл скрипта

• service zygote: Указывает, что процесс Zygote запущен как сервис
• /system/bing/app_process: Представляет файл приложения процесса Zygote
• Последние четыре параметра представляют параметры запуска процесса Zygote
  • —start-system-server: Указывает на то, что во время запуска процесса Zygote необходимо запустить системный процесс
• socket zygote stream 660 root system: Это означает, что в процессе запуска процесса Zygote необходимо создать сокет с именем zygote
  • Этот сокет используется для межпроцессного взаимодействия
  • Права доступа — 660 для корневой системы, то есть все пользователи могут читать и писать в нее.

Хорошо, мы обеспокоены тем, что вход в Зиготе в/system/bing/app_process Далее в каталоге проанализируем процесс его запуска

Процесс запуска Zygote

/system/bing/app_process Основная функция записи процесса Zygote в каталоге находится в app_main.cpp.

А) Основная функция app_main.cpp

Видно, что основной метод в app_main.cpp распределяет запуск Zygote в AndroidRuntime.start, а затем мы анализируем его

Хорошо, вы можете видеть, что запуск процесса Zygote вызывает метод AppRuntime.start. Этот метод выполняет следующие действия

• Создать виртуальную машину Java
• Создайте строковый массив для вызова метода java main ()
  • Импортируйте полное имя класса ZygoteInit
  • Импортируйте параметры в настройках
• Вызовите основной метод в ZygoteInti

Хорошо, пока запуск процесса Zygote был перенесен на Java, давайте посмотрим, что делается в ZygoteInit

2) Основной метод ZygoteInit

Видно, что основной метод ZygoteInit в основном делает следующие вещи

• Вызовите метод ZygoteServer.registerServerSocketFromEnv (), чтобы зарегистрировать сокет процесса Zygote, который используется для установления соединения между процессами
  • Сокет отвечает за связь с другими процессами, такими как: получение запроса AMS на создание процесса
• Вызовите ZygoteInit.forkSystemServer (), чтобы создать процесс системного обслуживания SystemService.
• Вызовите ZygoteServer.runSelectLoop (), чтобы открыть бесконечный цикл процесса Zygote и обработать запросы на создание, отправленные другими процессами.

Затем проанализируйте один за другим

1. Создать процесс Socket of Zygote

Хорошо, вы можете видеть, что Socket, который создал процесс Zygote, в конечном итоге получил LocalServerSocket и сохранил его в переменной-члене mServerSocket ZygoteServer

2. Запустите процесс SystemService

При запуске процесса Zygote мы видим, что процесс SystemServer находится в процессе запуска

• Сначала он будет заштрихован через метод Zygote.forkSystemServer
• Затем вызовите handleSystemServerProcess для обработки запуска SystemServer

Это будет проанализировано позже, мы будем продолжать смотреть вниз

3. Цикл процесса Zygote ожидает запросов на подключение от других процессов.

Хорошо, видно, что ZygoteServer откроет бесконечный цикл

• Непрерывно судите, есть ли данные, читаемые в Socket через fds
• i == 0: Указывает, что другие процессы установили соединение с текущим процессом Zygote через сокет
  • Создал объект подключения и добавил его в кеш пиров
  • Получить дескриптор файла из объекта подключения и добавить его в кеш fds
• i > 0: Выполнить инкубацию дочернего процесса
  • Вызовите ZygoteConnection.processOneCommand для инкубации процесса

Блок-схема запуска Zygote

На этом анализ Zygote при запуске процесса завершен, и приведенный выше код преобразуется во временную диаграмму, чтобы углубить впечатление.

Начало процесса обслуживания системы

В вышеупомянутом процессе запуска Zygote мы также инициировали запуск процесса SystemServer, первый обзор

При запуске процесса Zygote мы видим, что процесс SystemServer находится в процессе запуска

• Сначала он будет заштрихован через метод Zygote.forkSystemServer
• Затем вызовите handleSystemServerProcess для обработки запуска SystemServer

Инкубируйте процесс SystemServer

Затем проанализируйте метод Zygote.forkSystemServer ()

Видно, что forkSystemServer в Zygote перенаправляет работу по запуску процесса системного обслуживания на собственный уровень, мы продолжаем отслеживать

Видно, что в конечном итоге будет вызван метод fork для инкубации процесса, и процесс инкубации не будет подробно изучен. В основном мы сосредоточены на запуске системы SystemServer.

Обработка запуска SystemServer

Хорошо, вы можете видеть, что ZygoteInit.handleSystemServerProcess, наконец, перенаправил запуск SystemServer в RuntimeInit.applicationInit, мы продолжаем анализировать

Из построения аргументов в ZygoteInit.forkSystemServer мы видим, что запись этой основной функции на самом деле находится в «com.android.server.SystemServer», мы продолжаем отслеживать

Видно, что основная функция SystemServer, в основном, выполняется операцией

• Создан контекст SystemServer
  • Вызовите ActivityThread.systemMain, чтобы получить экземпляр ActivityThread
  • Получить объект Context через экземпляр ActivityThread
• Созданный объект SystemServiceManager, мы хорошо знакомы с этим объектом, это объект сущности Binder системы управления сервисами
• Запустите системные сервисы: AMS, WMS, PMS .

На этом этапе процесс обслуживания системы запускается и завершается

подводить итоги

Zygote

Об обязанностях процесса Zygote можно ясно видеть из ZygoteInit.main, вот краткое изложение

• Zygote запускается во время процесса запуска процесса инициализации
• Начало Zygote делится на следующие шаги:
  • Вызовите основную функцию app_main.cpp
  • Вызовите основной метод ZygoteInit
• Следующие три вещи были сделаны во время запуска Zygote
  • Создайте процесс Socket of Zygote, используемый для установления связи с другими процессами, для межпроцессного взаимодействия
  • Инкубируйте процесс SystemService
  • Откройте бесконечный цикл и продолжайте отслеживать, есть ли запрос на инкубацию процесса в Socket

SystemServer

Из метода run объекта SystemServer вы можете четко понять его работу при запуске

Источник

«Холодный» запуск Android-приложения

Всем приветъ! Давно ничего не писал.

Это будет серия постов о процессе «холодного» запуска Android приложения, с момента нажатия на иконку и до создания процесса приложения.

Общая схема

Открывая «окно»…

Перед тем как запустить новый процесс приложения, system_server создает стартовое окно используя метод PhoneWindowManager.addSplashScreen():

Стартовое окно это то, что пользователь будет видеть пока запускается само приложение. Окно будет отображаться до тех пор пока не будет запущена Activity и не будет отрисован первый кадр. То есть пока не будет завершен «холодный» запуск. Пользователь может видеть данное окно длительное время, поэтому постарайтесь сделать его приятным.

Содержимое стартового окна берется из drawable-ресурсов windowSplashscreenContent и windowBackground запускаемого Activity. Банальный пример такого окна:

Если пользователь восстанавливает Activity из режима последнего экрана(Recent screen), при этом на нажимая на иконку приложения, то system_server вызывает метод TaskSnapshotSurface.create(), чтобы создать стартовое окно из уже сделанного скриншота.

Как только стартовое окно показано пользователю, system_server готов запустить процесс приложения и вызывает метод ZygoteProcess.startViaZygote():

В коде видно, что метод ZygoteProcess.zygoteSendArgsAndGetResult() отправляет аргументы запуска через сокет Zygote-процессу.

«Разделение» Zygote-ы

Каждый процесс приложения запускается с помощью форкания(разделения) от существующего Zygote-процесса…

Вкратце об этом я писал в предыдущей статье про запуск Android-а. А теперь давайте посмотрим поглубже на происходящие процессы.

Когда система загружается процесс Zygote стартует и выполняет метод ZygoteInit.main():

Как вы видите метод ZygoteInit.main() делает 2 важные вещи:

• Подгружает все необходимые системные библиотеки и ресурсы Android-фреймворка. Подобная предзагрузка не только экономит память но еще и экономит время запуска приложений.
• Далее он запускает метод ZygoteServer.runSelectLoop(), который в свою очередь запускает сокет и начинает слушать вызовы данного сокета.

Когда же на сокет приходит команда на форкинг процесса, метод ZygoteConnection.
processOneCommand() обрабатывает аргументы используя метод ZygoteArguments.parseArgs() и запускает метод Zygote.forkAndSpecialize():

На заметку: Начиная с Android 10 есть оптимизационная фича под названием Unspecialized App Process, которая имеет пул не специализированных Zygote-процессов, для еще более быстрого запуска приложений.

Приложение запустилось!

После форка дочерний процесс запускает метод RuntimeInit.commonInit(), который устанавливает дефолтный UncaughtExceptionHandler. Далее, процесс запускает метод ActivityThread.main():

Тут происходят две интересные вещи:

• Метод ActivityThread.main() создает новый поток(Thread) и вызывает метод Looper.loop(), в котором будет запущен новый инстанс Looper-а. Он будет привязан к новому потоку(который становится MainThread-ом aka UiThread) и будет работать(теоретически) бесконечно. Looper привязавшись, будет ожидать сообщений для того чтобы поместить их к своему MessageQueue.
• Далее, метод ActivityThread.attach() делает IPC-запрос к методу ActivityManagerService.attachApplication()system_server-а, тем самым давая понять, что MainThread нашего приложения запущен и готов к работе.

Контроль над приложением

В процессе system_server метод ActivityManagerService.attachApplication() вызывает метод ActivityManagerService.attachApplicationLocked(), который завершает настройку запускаемого приложения:

Парочка ключевых выводов:

• Процесс system_server делает IPC-запрос к методу ActivityThread.bindApplication() в процессе нашего приложения, который направляет запрос к методу ActivityThread.handleBindApplication() в MainThread-е приложения.
• Сразу после этого, system_server планирует запуск Pending Activity, Service и BroadcastReciever-ов нашего приложения.
• Метод ActivityThread.handleBindApplication() загружает APK-файл и компоненты приложения.
• Разработчики имеют возможность немного повлиять на процессы перед запуском метода ActivityThread.handleBindApplication(), так что именно здесь должен начаться мониторинг холодного запуска приложения.

Давайте немного подробно разберем 3-ий пункт и узнаем что и как происходит при загрузке компонентов и ресурсов приложения. Порядок шагов такой:

• Загрузка и создание инстанса класса AppComponentFactory.
• Вызов метода AppComponentFactory.instantiateClassLoader().
• Вызов метода AppComponentFactory.instantiateApplication() для загрузки и создания инстанса класса Application.
• Для каждого объявленного ContentProvider-а, в порядке приоритета, вызов метода AppComponentFactory.instantiateProvider() для загрузки его класса и создания инстанса, после вызов метода ContentProvider.onCreate().
• И наконец, вызов метода Application.onCreate().

Эпилог

Мы начали изучать «холодную» загрузку с очень обще-абстрагированного уровня:

Теперь мы знаем, что происходит «под капотом»:

Ну что же, это был длинный пост. Но это не все! В следующих постах мы продолжим глубокое погружение в процесс запуска Android-приложения. Оставайтесь с нами!

Источник

Русские Блоги

Zygote для Android

Что такое зигота

Zygote — это сервис-демон. SystemServer и все другие процессы виртуальной машины Dalvik разрабатываются Zygote.

Zygote — это самый важный процесс в Android и процесс Init. Процесс SystemServer — это три полюса, которые поддерживают мир Android. Процесс Zygote запускается как служба в процессе Init.

Zygote — это модель C / S. Процесс Zygote выступает в качестве сервера, а другие процессы выступают в качестве клиентов для отправки ему «инкубационных» запросов. Zygote «инкубирует» новый процесс после получения этого запроса. Как показано на рисунке, при щелчке по значку приложения в Launcher для запуска нового процесса приложения запрос достигает основной службы ActivityManagerService уровня платформы. Когда AMS получает этот запрос, он выполняет вызов, вызывая класс Process. «Зафиксируйте» запрос сокета дочернего процесса, и Zygote разветвляет новый процесс сразу после прослушивания этого запроса.

Процесс запуска Zygote

Основной файл, соответствующий процессу Zygote, это app_main.cpp. Когда он запускается процессом Init, он входит в функцию main () основного файла app_main.cpp. Затем его основная функция начинает анализ запуска процесса Zygote:

Наконец, функция main () вызывает функцию start () среды выполнения. Runtime — это объект AppRuntime. Взгляните на класс AppRuntime:

Класс AppRuntime наследует класс AndroidRuntime, поэтому функция start () среды выполнения, вызванная ранее, войдет в функцию start () AndroidRuntime. Взгляните на функцию ниже:

Функция start () AndroidRuntime в основном выполняет следующие три функции:
1. Вызовите функцию startVM (), чтобы запустить виртуальную машину.
2. Вызовите функцию startReg (), чтобы зарегистрировать метод JNI.
3. Вызовите функцию main () класса com.android.internal.os.ZygoteInit (если это дочерний процесс, вызовите функцию main () com.android.internal.os.RuntimeInit Это в основном завершает инициализацию. Основная функция процесса Zygote имеет следующие 5 задач)

Далее описывается конкретная работа трех функций одна за другой:

Запустите виртуальную машину

Запустите виртуальную машину, вызвав функцию startVM ():

Зарегистрировать метод JNI

В Android мир Java использует механизм JNI для вызова функций в собственном мире, а механизм JNI также широко используется в системе Android.В системе Android для регистрации используется следующая функция startReg ():

Функция startReg () дополнительно регистрируется путем вызова функции register_jni_procs (). Переданное значение — массив gRegJNI. Версия Android 6.0 имеет более 130 массивов, как показано ниже:

JNI, перечисленные выше, регистрируются с помощью функции register_jni_procs ():

Зарегистрируйте все функции JNI через цикл. , ,

ZygoteInit отвечает за инициализацию Zygote. Вот основной метод класса ZygoteInit

1) Зарегистрируйте порт сокета в zygote для прослушивания

2) предварительная загрузка системных ресурсов;

3) Запустите процесс SystemServer;

4) войти в цикл прослушивания и получения сообщений;

Взгляните на эти четыре метода по очереди:

1) метод registerZygoteSocket ()

Создайте локальный сокет, а затем дождитесь вызова runSelectLoop (), чтобы войти в цикл, ожидающий сокет для ожидания соединения;

2) предварительная загрузка системных ресурсов, метод preload ();

Сначала посмотрите на карту общей памяти процесса приложения Android

Из приведенного выше рисунка легко понять, что после того, как процесс Zygote предварительно загружает системные ресурсы, он затем штрихует другие процессы виртуальной машины, а затем разделяет память виртуальной машины и ресурсы уровня структуры, что значительно повышает скорость запуска и запуска приложений. Теперь посмотрим на метод preload ();

В основном предварительная загрузка различных системных ресурсов, в основном см. 2.1) предварительная загрузка системных классов; 2.2) предварительная загрузка системных ресурсов; 2.3) предварительная загрузка, так что библиотека

Прочитайте файлы в файле PRELOADED_CLASSES, получите объект InputStream, преобразуйте его в BufferedReader, построчно прочитайте содержимое файла, передайте trim (), отфильтруйте пустые строки, а затем вызовите метод Class.forName () для загрузки информации о классе Java Вместо создания объекта;

2.2 preloadResources (); предварительная загрузка системных ресурсов

2.3 preloadSharedLibraries (); загрузка системных общих библиотек

3 startSystemServer () запускает процесс SystemServer

Было выполнено три основных действия: 3.1) Подготовить параметры для запуска процесса SystemServer. Вы можете видеть, что ProcessId и Group Id SystemServer оба равны 1000. Класс выполнения SystemServer — com.android.server.SystemServer; 3.2) Форкировать процесс SystemServer; 3.3) После того, как процесс SystemServer разветвлен, инициализируйте процесс SystemServer;
3.1 метод handleSystemServerProcess ()

4) метод runSelectLoop ()

Это делает две основные вещи:

4.1) Принять запрос на соединение, i = 0, это означает, что событие запроса на соединение наступило, вызвать acceptCommandPeer (), чтобы установить соединение с клиентом через сокет, а затем присоединиться к массиву прослушивания, ожидая прибытия команды на этом сокете;

4.2) Принять сообщение; i> 0 означает, что у уже подключенного сокета есть данные. После вызова метода runOnce () класса ZygoteConnection соединение с клиентом будет отключено и удалено из прослушивающего массива;

Источник