Глава 12. Исполнение

Виртуальная машина Java начинает выполнение, вызывая метод main определенного класса или интерфейса, передавая ему единственный аргумент — массив строк. В примерах в этом спецификации этот первый класс обычно называется Test.

Точные семантики запуска виртуальной машины Java приведены в главе 5 спецификации Спецификация виртуальной машины Java, издание Java SE 24. Здесь мы представляем общий обзор процесса с точки зрения языка программирования Java.

Способ указания начального класса или интерфейса виртуальной машине Java выходит за рамки этой спецификации, но обычно в средах, использующих командную строку, указывается полное имя класса или интерфейса в качестве аргумента командной строки, а последующие аргументы командной строки используются в качестве строк, передаваемых в метод main.

java Test reboot Bob Dot Enzo

Теперь мы очертим шаги, которые виртуальная машина Java может предпринять для выполнения Test, как пример процессов загрузки, компоновки и инициализации, описанных далее в последующих разделах.

public static void main(String[] args)

public static void main(String... args)

Загрузка относится к процессу поиска двоичной формы класса или интерфейса с определённым именем, возможно, вычисляя его на лету, но чаще всего извлекая ранее вычисленное двоичное представление из исходного кода с помощью компилятора Java и, на основе этой двоичной формы, создавая объект для представления класса или интерфейса (§1.4).

Точные семантики загрузки приведены в главе 5 спецификации виртуальной машины Java, Java SE 24 Edition. Здесь мы представляем общий обзор процесса с точки зрения языка программирования Java.

Двоичное представление класса или интерфейса обычно имеет формат файла class, описанный в главе 4 спецификации виртуальной машины Java, Java SE 24 Edition, но возможны и другие представления, при условии что они соответствуют требованиям, указанным в §13.1.

Связывание — это процесс взятия двоичной формы класса или интерфейса и объединения её в состояние выполнения виртуальной машины Java, чтобы её можно было выполнить. Класс или интерфейс всегда загружается перед связыванием.

Точные семантики связывания приведены в главе 5 спецификации виртуальной машины Java, Java SE 24 издание. Здесь мы представим обзор процесса с точки зрения языка программирования Java.

В связывании участвуют три различных действия: проверка, подготовка и разрешение символических ссылок.

Эта спецификация предоставляет реализациям гибкость в том, когда происходят действия связывания (и, из-за рекурсии, загрузки), при условии, что соблюдаются семантики языка программирования Java, что класс или интерфейс полностью проверен и подготовлен перед его инициализацией, и что ошибки, обнаруженные во время связывания, выбрасываются в точке программы, где выполняется какое-либо действие программы, которое может потребовать связывания с классом или интерфейсом, связанным с ошибкой.

Например, реализация может выбрать разрешение каждой символической ссылки в классе или интерфейсе по отдельности только при её использовании (ленивое или отложенное разрешение) или разрешить их все сразу во время проверки класса (статическое разрешение). Это означает, что процесс разрешения может продолжаться в некоторых реализациях после инициализации класса или интерфейса.

Поскольку связывание включает выделение новых структур данных, оно может завершиться с ошибкой OutOfMemoryError.

Новый экземпляр класса явно создается при вычислении выражения создания экземпляра класса (§15.9), что приводит к созданию экземпляра класса.

Новый экземпляр класса может быть неявно создан в следующих ситуациях:

В каждой из этих ситуаций определен конкретный конструктор (§8.8), который должен быть вызван со специфицированными аргументами (возможно, ни с какими) в рамках процесса создания экземпляра класса.

При создании нового экземпляра класса выделяется память для него с местом для всех переменных экземпляра, объявленных в классе, и всех переменных экземпляра, объявленных в каждом суперклассе класса, включая все переменные экземпляра, которые могут быть скрыты (§8.3).

Если доступно недостаточно места для выделения памяти для объекта, то создание экземпляра класса завершается внезапно с OutOfMemoryError. В противном случае все переменные экземпляра в новом объекте, включая те, которые объявлены в суперклассах, инициализируются их значениями по умолчанию (§4.12.5).

Непосредственно перед возвратом ссылки на вновь созданный объект в качестве результата, указанный конструктор обрабатывается для инициализации нового объекта с использованием следующей процедуры:

В отличие от C++, язык программирования Java не указывает измененных правил для диспетчеризации методов во время создания нового экземпляра класса. Если вызываются методы, переопределенные в подклассах в инициализируемом объекте, то эти переопределенные методы используются, даже до полного инициализации нового объекта.

class Point {
    int x, y;
    Point() { x = 1; y = 1; }
}
class ColoredPoint extends Point {
    int color = 0xFF00FF;
}
class Test {
    public static void main(String[] args) {
        ColoredPoint cp = new ColoredPoint();
        System.out.println(cp.color);
    }
}

ColoredPoint() { super(); }

Point() { super(); x = 1; y = 1; }

Object() { }

class Super {
    Super() { printThree(); }
    void printThree() { System.out.println("three"); }
}
class Test extends Super {
    int three = (int)Math.PI;  // That is, 3
    void printThree() { System.out.println(three); }

    public static void main(String[] args) {
        Test t = new Test();
        t.printThree();
    }
}

0
3

Реализация языка программирования Java может выгружать классы.

Класс или интерфейс могут быть выгружены только в том случае, если его определяющий загрузчик классов может быть удалён сборщиком мусора, как обсуждается в §12.6.

Классы и интерфейсы, загруженные загрузчиком базового уровня, не могут быть выгружены.

Выгрузка классов — оптимизация, которая помогает уменьшить использование памяти. Очевидно, семантика программы не должна зависеть от того, выбирает ли система реализацию такой оптимизации, как выгрузка классов, и как это делает. В противном случае это повлияет на переносимость программ. Соответственно, то, загружен ли класс или интерфейс или нет, должно быть прозрачно для программы.

Однако, если класс или интерфейс C был выгружен, в то время как его определяющий загрузчик был потенциально достижимым, то C может быть перезагружен. Нельзя гарантировать, что этого не произойдёт. Даже если к классу не ссылается ни один другой загруженный класс, на него может ссылаться какой-либо класс или интерфейс D, который ещё не загружен. Загрузка D определяющим загрузчиком C может привести к перезагрузке C.

Перезагрузка может быть не прозрачной, если, например, класс имеет static переменные (состояние которых будет потеряно), статические инициализаторы (которые могут иметь побочные эффекты) или native методы (которые могут сохранять статическое состояние). Кроме того, хеш-значение объекта Class зависит от его идентификатора. Поэтому, как правило, невозможно перезагрузить класс или интерфейс полностью прозрачным образом.

Поскольку мы никогда не можем гарантировать, что выгрузка класса или интерфейса, определяющего загрузчик которого потенциально достижим, не приведёт к его перезагрузке, а перезагрузка никогда не является прозрачной, но выгрузка должна быть прозрачной, следует, что класс или интерфейс нельзя выгружать, пока его загрузчик потенциально достижим. Аналогичным образом можно сделать вывод, что классы и интерфейсы, загруженные загрузчиком базового уровня, никогда не могут быть выгружены.

Необходимо также обосновать, почему безопасно выгружать класс C, если его определяющий загрузчик классов может быть удалён. Если определяющий загрузчик может быть удалён, значит, к нему не может быть живых ссылок (это включает ссылки, которые не являются активными, но могут быть восстановлены финализаторами). Это, в свою очередь, может быть истинным только в том случае, если не может быть активных ссылок на какие-либо классы, определённые этим загрузчиком, включая C, ни из их экземпляров, ни из кода.

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

Строго говоря, обсуждение вопроса о выгрузке классов в этом спецификации не обязательно, так как выгрузка классов — всего лишь оптимизация. Однако этот вопрос очень тонкий, и поэтому он упомянут здесь для уточнения.

Программа состоит из одной или нескольких потоков выполнения. Поток является либо потоком-не-демоном, потоком-демоном, либо обработчиком завершения.

Подробную информацию о том, как потоки получают статус демона, и о регистрации обработчиков завершения, см. в спецификациях API Thread и Runtime.

Поток завершается, если (i) его метод run завершается нормально, или (ii) его метод run завершается внезапно, и соответствующий обработчик необработанных исключений (§11.3) завершается нормально или внезапно. Без кода для выполнения поток завершил выполнение и, следовательно, не имеет текущего метода (JVMS §2.5.1).

Программа завершается, когда произошла одна из следующих ситуаций:

При завершении программы любой поток-демон или поток-не-демон, который еще не завершен, не выполнит дальнейший код Java. Текущий метод потока не завершается нормально или внезапно. Никакая часть finally любого метода в потоке не выполняется, а также ни один обработчик необработанных исключений.

Если завершение программы происходит потому, что поток вызвал Runtime.halt во время выполнения обработчиков завершения, то помимо потоков-демонов и потоков-не-демонов любой обработчик завершения, который еще не завершен, не выполнит дальнейший код Java.

За исключением этой необычной ситуации, связанной с Runtime.halt, завершение программы зависит от завершения любых обработчиков завершения, которые были запущены. Обоснование следующее. Когда количество потоков-не-демонов падает до нуля или поток вызывает System.exit или Runtime.exit, вероятно, программа больше не имеет работы и переходит к выходу; однако, у программы могут быть и другие потоки, выполняющие вспомогательные задачи, и было бы нежелательно останавливать их в самом начале. Обработчики завершения позволяют программе плавно прервать и завершить такие потоки в приложении-специфическим образом; следовательно, программа еще не завершена, если обработчики завершения все еще выполняются.

Приложения нативных языках могут использовать API вызова JNI для создания и уничтожения виртуальной машины Java таким образом, что программа Java, начавшая выполнение в методе main начального класса (§12.1), завершается, как описано в первой ситуации выше.