Как выгрузить dll из Java-машины

в 23:34, , рубрики: classloader, dll, gc, jar, java, library, memory leak, метки:

Java взаимодействует с операционной системой через методы, помеченные ключевым словом native, при помощи системных библиотек, загружаемых процедурой System.loadLibrary().

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

Предположим, мы хотим сделать небольшую утилиту, которую будут запускать пользователи на своих компьютерах в локальной сети. Нам бы хотелось избавить пользователей от проблем с установкой и настройкой программы, но нет ресурсов на развертывание и поддержку централизованной инфраструктуры. В таких случаях обычно собирают программу вместе со всеми зависимостями в единый jar-файл. Это легко сделать при помощи maven-assembly-plugin или просто экспортировать из IDE Runnable jar. Запуск программы будет осуществляться командой:

java -jar my-program.jar

К сожалению, это не работает, если одна из библиотек требует для своей работы системную динамическую библиотеку, проще говоря dll. Обычно в одном из классов такой библиотеки в статическом инициализаторе делается вызов System.loadLibrary(). Чтобы dll загрузилась, нужно положить ее в каталог, доступный через системное свойство JVM java.library.path. Как это ограничение можно обойти?

Запакуем dll внутрь jar-файла. Перед началом использования классов, требующих подгрузки dll, создадим временный каталог, извлечем библиотеку туда и добавим каталог в java.library.path. Выглядеть это будет примерно так:

prepareLibrary

private void addLibraryPath(String pathToAdd) throws ReflectiveOperationException {
    Field usrPathsField = ClassLoader.class.getDeclaredField("usr_paths");
    usrPathsField.setAccessible(true);
    String[] paths = (String[]) usrPathsField.get(null);
    String[] newPaths = Arrays.copyOf(paths, paths.length + 1);
    newPaths[newPaths.length - 1] = pathToAdd;
    usrPathsField.set(null, newPaths);
}
private Path prepareLibrary() throws IOException, ReflectiveOperationException {
    Path dir = Files.createTempDirectory("lib");
    try (InputStream input = ExampleClass.class.getResourceAsStream("custom.dll")) {
        if (input == null) {
            throw new FileNotFoundException("Can't load resource custom.dll");
        }
        Files.copy(input, dir.resolve("custom.dll"));
    }
    addLibraryPath(dir.toAbsolutePath().toString());
    return dir;
}

К сожалению, приходится химичить с reflection, потому что стандартных методов расширить java.library.path Java не предоставляет.

Теперь загрузка библиотеки проходит для пользователя прозрачно, и он не должен беспокоиться о копировании файлов или настройке переменных окружения. Для работы по-прежнему достаточно просто запустить обычный скрипт. Однако после каждого запуска программы остается временный каталог с файлами. Это не очень хорошо, поэтому на выходе надо выполнить очистку.

try {
    ...
} finally {
    delete(dir);
}

Но на Windows это не работает. Загруженная в JVM библиотека блокирует dll-файл и каталог, в котором он лежит. Таким образом, чтобы решить задачу аккуратного завершения программы, надо выгрузить из JVM системную динамическую библиотеку.

Попытка решения

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

if (!delete(dir)) {
    forceDelete(dir);
}

Как быстрое, но не самое красивое решение, я использовал планировщик. На выходе создаю xml-файл с заданием на выполнение через 1 минуту команды «cmd /c rd /s /q temp-dir» и загружаю задание в планировщик командой «schtasks -create taskName -xml taskFile.xml». К моменту выполнения задания программа уже завершена, и файлы никто не держит.

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

Использование класслоадера

В моей программе проблемы исходили из JDBC-драйвера, поэтому дальше я буду рассматривать пример с JDBC. Но и с другими библиотеками можно работать аналогичным образом.

Если dll загружена из системного загрузчика классов, то выгрузить ее уже не получится, поэтому необходимо создать свой класслоадер таким образом, чтобы класс, подтягивающий библиотеку, был загружен из него. Новый класслоадер должен быть связан с системным класслоадером через свойство parent, иначе в нем не будут доступны классы String, Object и другие необходимые в хозяйстве в вещи.

Попробуем:

Загрузка класса из нового загрузчика (1)
ClassLoader parentCl = ExampleClass.class.getClassLoader();
classLoader = new URLClassLoader(new URL[0], parentCl);
Class.forName("org.jdbc.CustomDriver", classLoader, true);
try (Connection connection = DriverManager.getConnection(dbUrl, dbProperties)) {
    if (connection.getClass().getClassLoader() != classLoader) {
        System.out.printf("Что-то пошло не так%n");
    }
    ...
}

Не работает. При загрузке класса сначала производится попытка поднять его из родительского загрузчика, поэтому наш драйвер загрузился не так, как нам нужно. Для использования нового класслоадера, нужно JDBC-драйвер из jar-файла программы удалить, чтобы он не был доступен системному загрузчику. Значит, запаковываем библиотеку в виде вложенного jar-файла, а перед использованием разворачиваем его во временном каталоге (в том же, где и dll у нас лежит).

Загрузука класса из нового загрузчика (2)

ClassLoader cl = ExampleClass.class.getClassLoader();
URL url = UnloadableDriver.class.getResource("CustomJDBCDriver.jar");
if (url == null) {
    throw new FileNotFoundException("Can't load resource CustomJDBCDriver.jar");
}
Path dir = prepareLibrary();
try (InputStream stream = url.openStream()) {
    Path target = dir.resolve("CustromJDBCDriver.jar");
    Files.copy(stream, target);
    url = target.toUri().toURL();
}
ClassLoader classLoader = new URLClassLoader(new URL[] {url}, cl);
Class.forName("org.jdbc.CustomDriver", true, classLoader);
try (Connection connection = DriverManager.getConnection(dbUrl, dbProperties)) {
    if (connection.getClass().getClassLoader() != classLoader) {
        System.out.printf("Что-то пошло не так%n");
    } else {
        System.out.printf("Получилось, можно идти дальше%n");
    }
    ...
}

Мы получили объект, загруженный из нашего нового загрузчика, по окончании работы нам надо позакрывать все, что мы открывали, почистить все наши переменные, и, видимо, вызвать System.gc(), после чего уже пытаться чистить файлы. В этом месте имеет смысл инкапсулировать всю логику работы с загрузчиками классов в отдельном классе с явными методами инициализации.

Скелет основного класса

public class ExampleClass implements AutoCloseable {
    private final Path dir;
    private URLClassLoader classLoader;

    public ExampleClass() {
        ...
    }

    public void doWork() {
        ...
    }

    @Override
    public void close() {
        ...
        this.classLoader.close();
        this.classloader = null;
        System.gc(); // где-то здесь должна выгрузиться dll
        if (!delete(this.dir)) {
            scheduleRemovalToTaskschd(this.dir);
        }
    }
}

public class Main {
    public static void main(String args[]) {
        try (ExampleClass example = new ExampleClass()) {
            example.doWork();
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
}

Эксперименты со сборщиком мусора

Несмотря на то, что вроде бы формально все необходимое для выгрузки библиотеки сделано, фактически выгрузка не происходит. Чтение исходников из пакетка java.lang позволило определить, что удаление нативных библиотек производится в методе finalize() в одном из внутренних классов. Это огорчает и настораживает, потому что документация не дает никакого точного определения, когда выполнится данный метод и выполнится ли вообще. Т. е. успех зависит от каких-то факторов, которые могут различаться в различном окружении, в различных версиях JVM или в различных сборщиках мусора. Тем не менее имеется метод System.runFinalization(), который дает некоторую надежду.

Пробуем:

Run finalization...

@Override
public void close() {
    ...
    this.classLoader.close();
    this.classloader = null;
    System.gc();
    System.runFinalization(); // где-то здесь должна выгрузиться dll
    if (!delete(this.dir)) {
        scheduleRemovalToTaskschd(this.dir);
    }
}

Не работает. Каталог заблокирован процессом java. С этого момента я использовал такую технику:

  1. Ставлю на выходе System.in.read()
  2. Когда программа останавливается в этом месте, делаю дамп памяти из jvisualvm
  3. Смотрю дамп при помощи Eclipse Memory Analysis Tool или jhat
  4. Ищу экземпляры объектов, классы которых были загружены мои загрузчиком

Обнаружилось 5 источников утечки:

  1. Локальные переменные
  2. DriverManager
  3. ResourceBundle
  4. ThreadLocals
  5. Исключения

Локальные переменные

Локальные переменные

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

if (needConnection) {
    try (Connection connection = DriverManager.connect()) {
        ...
    }
}
// Вот здесь переменна connection еще считается живой.

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

DriverManager

DriverManager

JDBC-драйверы при загрузке их класса регистрируются в классе DriverManager методом registerDriver(). Судя по всему, перед выгрузкой надо вызвать метод deregisterDriver(). Пробуем.

Enumeration<Driver> drivers = driverManager.getDrivers();
while (drivers.hasMoreElements()) {
    Driver driver = drivers.nextElement();
    if (driver.getClass().getClassLoader() == classLoader) {
        DriverManager.deregisterDriver(driver);
        break;
    }
}

Не работает. Heapdump не изменился. Смотрим в исходники класса DriverManager и обнаруживаем, что в методе deregisterDriver() стоит проверка на то, что вызов должен быть из класса, который принадлежит тому же класслоадеру, что и класс, вызвавший ранее registerDriver(). А registerDriver() вызван самим драйвером из статического инициализатора. Неожиданный поворот.

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

public interface DriverManagerProxy {
    void deregisterDriver(Driver driver) throws SQLException;
}

public class DriverManagerProxyImpl implements DriverManagerProxy {
    @Override
    public void deregisterDriver(Driver driver) throws SQLException {
        DriverManager.deregisterDriver(driver);
    }
}

Интерфейс будет находиться в основном classpath-е, а релизация будет загружена новым загрузчиком из вспомогательного jar-файла вместе с JDBC-драйвером. Теоретически без интерфейса можно было бы обойтись, но тогда для вызова функции пришлось бы применять reflection. Используется прокси следующим образом:

Использование DriverManagerProxy

public class ExampleClass implements AutoCloseable {
    private final Path dir;
    private URLClassLoader classLoader;
    private DriverManagerProxy driverManager;

    public ExampleClass() {
        ...
        this.classLoader = ...;
        Class.forName("org.jdbc.CustomDriver", true, classLoader);
        Class<?> dmClass = Class.forName("ru.example.DriverManagerProxyImpl",
                                         true,
                                         classLoader);
        this.driverManager = (DriverManagerProxy) dmClass.newInstance();
    }

    public void doWork() {
        ...
    }

    @Override
    public void close() {
        ...
        Enumeration<Driver> drivers = driverManager.getDrivers();
        while (drivers.hasMoreElements()) {
            Driver driver = drivers.nextElement();
            if (driver.getClass().getClassLoader() == classLoader) {
                driverManager.deregisterDriver(driver);
                break;
            }
        }
        this.driverManager = null;
        this.classLoader.close();
        this.classloader = null;
        System.gc();
        System.runFinalization(); // где-то здесь должна выгрузиться dll
        if (!delete(this.dir)) {
            scheduleRemovalToTaskschd(this.dir);
        }
    }
}

ResourceBundle

ResourceBundle

Следующая зацепка на класслоадер, который я пытался выгрузить, обнаружилась в недрах класса ResourceBundle. К счастью, в отличие от DriverManager, ResourceBundle предоставляет специальную функцию clearCache(), которой класслоадер передается в качестве параметра.

ResourceBundle.clearCache(classLoader);

Надо заметить, что, судя по исходникам, в ResourceBundle используются слабые ссылки, которые не должны препятствовать сборке мусора. Возможно, если очистить все остальные ссылки на наши объекты, то чистить этот кэш нет необходимости.

ThreadLocals

ThreadLocals

Последнее место, где обнаружились хвосты неиспользуемого драйвера, оказалось ThreadLocals. После истории с DriverManager-ом, очистка локальных поточных переменных кажется парой пустяков. Хотя тут не удалось обойтись без reflection.

private static void cleanupThreadLocals(ClassLoader cl)
        throws ReflectiveOperationException {
    int length = 1;
    Thread threads[] = new Thread[length];
    int cnt = Thread.enumerate(threads);
    while (cnt >= length) {
        length *= 2;
        threads = new Thread[length];
        cnt = Thread.enumerate(threads);
    }
    for (int i = 0; i < cnt; i++) {
        Thread thread = threads[i];
        if (thread == null) {
            continue;
        }
        cleanupThreadLocals(thread, cl);
    }
}

private static void cleanupThreadLocals(Thread thread, ClassLoader cl)
        throws ReflectiveOperationException {
    Field threadLocalsField = Thread.class.getDeclaredField("threadLocals");
    threadLocalsField.setAccessible(true);
    Object threadLocals = threadLocalsField.get(thread);
    if (threadLocals == null) {
        return;
    }
    Class<?> threadLocalsClass = threadLocals.getClass();
    Field tableField = threadLocalsClass.getDeclaredField("table");
    tableField.setAccessible(true);
    Object table = tableField.get(threadLocals);
    Object entries[] = (Object[]) table;
    Class<?> entryClass = table.getClass().getComponentType();
    Field valueField = entryClass.getDeclaredField("value");
    valueField.setAccessible(true);
    Method expungeStaleEntry = threadLocalsClass.getDeclaredMethod("expungeStaleEntry", Integer.TYPE);
    expungeStaleEntry.setAccessible(true);
    for (int i = 0; i < entries.length; i++) {
        Object entry = entries[i];
        if (entry == null) {
            continue;
        }
        Object value = valueField.get(entry);
        if (value != null) {
            ClassLoader valueClassLoader = value.getClass().getClassLoader();
            if (valueClassLoader == cl) {
                ((java.lang.ref.Reference<?>) entry).clear();
                expungeStaleEntry.invoke(threadLocals, i);
            }
        }
    }
}

Исключения

Исключения

Мы рассчитываем на то, что код очистки можно поместить в блоке finally. На входе в этот блок у нас уже должно быть все закрыто автоматически при помощи механизма try-with-resources. Однако наш класслоадер по-прежнему не будет в этом месте удален из памяти, если из блока try выброшено исключение, класс которого загружен этим класслоадером.

Чтобы удалить из памяти нежелательный exception, его надо поймать и обработать, а если нужно ошибку все-таки выбросить наверх, то скопировать exception в другой класс. Вот как это сделал я в своей программе:

try {
    ...
} catch (RuntimeException e) {
    if (e.getClass().getClassLoader() == this.getClass().getClassLoader()) {
        throw e;
    }
    RuntimeException exception = new RuntimeException(String.format("%s: %s", e.getClass(), e.getMessage()));
    exception.setStackTrace(e.getStackTrace());
    throw exception;
} catch (SQLException e) {
    if (e.getClass().getClassLoader() == this.getClass().getClassLoader()) {
        throw e;
    }
    SQLException exception = new SQLException(String.format("%s: %s", e.getClass(), e.getMessage()));
    exception.setStackTrace(e.getStackTrace());
    throw exception;
}

Java наносит ответный удар

После очистки всех обнаруженных ссылок на выгружаемые классы получилась немного парадоксальная ситуация. Никаких объектов в памяти нет, судя по дампу памяти, количество экземпляров во всех классах равно 0. Но сами классы и их загрузчик никуда не делись, и соответственно не удалилась нативная библиотека.

Устранить проблему получилось вот таким приемом:

System.gc();
System.runFinalization();
System.gc();
System.runFinalization();

Наверное, в Java 1.7, которую я использовал, была какая-то особенность очистки объектов, которые лежат в PermGen. С настройками сборки мусора я не экспериментировал, потому что старался написать код, который будет одинаково работать в различном окружении, в том числе в серверах приложений.

После указанного приема код заработал как следует, библиотека выгружалась, каталоги удалялись. Однако после перехода на Java 8 проблема вернулась. Разобраться, в чем дело, не было времени, но судя по всему, изменилось что-то в поведении сборщика мусора.

Поэтому пришлось применить тяжелую артиллерию, а именно JMX:

Как заставить Java собрать мусор

private static void dumpHeap() {
    try {
        Class<?> clazz = Class.forName("com.sun.management.HotSpotDiagnosticMXBean");
        MBeanServer server = ManagementFactory.getPlatformMBeanServer();
        Object hotspotMBean =
                ManagementFactory.newPlatformMXBeanProxy(
                        server, "com.sun.management:type=HotSpotDiagnostic", clazz);
        Method m = clazz.getMethod("dumpHeap", String.class, boolean.class);
        m.invoke(hotspotMBean, "nul", true);
    } catch (@SuppressWarnings("unused") RuntimeException e) {
        return;
    } catch (@SuppressWarnings("unused") ReflectiveOperationException e) {
        return;
    } catch (@SuppressWarnings("unused") IOException e) {
        return;
    }
}

Через HotSpotDiagnosticMXBean вызываем сохранение дампа памяти. В качестве имени файла указываем nul, что в Windows означает то же самое, что и /dev/null в Unix. Второй параметр указывает на то, что в дамп должны быть выгружены только живые объекты. Именно этот параметр заставляет JVM выполнить полную сборку мусора.

Вот после этого лайфхака проблема удаления библиотеки из временного каталога больше не возникала. Итоговый код очистки файлов выглядит так:

this.classLoader = null;
System.gc();
System.runFinalization();
System.gc();
System.runFinalization();
if (!delete(this.dir)) {
    dumpHeap();
    if (!delete(this.dir)) {
        scheduleRemovalToTaskschd(this.dir);
    }
}

Проверка при помощи OSGI

Для проверки качества кода я написал свой JDBC-драйвер, который полностью убирает за собой. Он работает как обертка вокруг любого другого драйвера, подгружаемого из отдельного classpath.

UnloadableDriver

public class UnloadableDriver implements Driver, AutoCloseable {
    private final Path dir; // временный каталог, подлежащий удалению
    private URLClassLoader classLoader;
    private DriverManagerProxy driverManager;
    private Driver driver;

    public UnloadableDriver() throws SQLException {
        ...
    }

    @Override
    public void close() {
        ...
    }

    ...
}

Этот драйвер я вставил в сервис OSGI на Apache Felix.

JDBCService

public interface JDBCService {
    Connection getConnection(String url, Properties properties) throws SQLException;
}

@Service(JDBCService.class)
public class JDBCServiceImpl implements JDBCService {
    private UnloadableDriver driver;

    @Activate
    public void activate(ComponentContext ctx) throws SQLException {
        this.driver = new UnloadableDriver();
    }

    @Deactivate
    public void deactivate() {
        this.driver.close();
        this.driver = null;
    }

    @Override
    public Connection getConnection(String url, Properties info) throws SQLException {
        return this.driver.connect(url, properties);
    }
}

При старте модуля через системную консоль Apache Felix, запущенную на Java 1.8.0_102, появляется временный каталог с dll-файлом. Файл заблокирован процессом java. Как только модуль останавливается, каталог удаляется автоматически. Если же вместо UnloadableDriver использовать DriverManager и обычную библиотеку из Embedded-Artifacts, то после обновления модуля возникает ошибка java.lang.UnsatisfiedLinkError: Native Library already loaded in another classloader.

Выводы

Универсального способа выгрузить системную динамическую библиотеку из Java-машины не существует, но задача эта решаема.

В Java существует немало мест, в которых можно случайно оставить ссылки на свои классы, и это является предпосылкой к утечкам памяти.

Даже если ваш код делает все корректно, утечка может быть привнесена какой-нибудь библиотекой, которую вы используете.

Особое внимание следует обратить на случаи, когда программа что-то загружает при помощи создаваемого во время выполнения нового загрузчика классов. Если останется хотя бы одна ссылка на один из загруженных классов, то класслоадер и все его классы останутся в памяти.

Чтобы обнаружить утечку памяти, надо сделать дамп и проанализировать при помощи специальных инструментов, таких как Eclipse MAT.

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

Автор: sergey-b

Источник

* - обязательные к заполнению поля


https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js