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.

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

Комментарии (21)


  1. apangin
    31.10.2016 02:54
    +5

    А-а-а! Зачем модифицировать приватные поля через Reflection?
    С выходом Java 9 — сразу до свидания!

    Не надо модифицировать java.library.path. Про System.load() слышали?


    1. sergey-b
      31.10.2016 03:30
      +1

      Дергать через reflection внутренние поля мне не доставляет никакого удовольствия. Поэтому я по максимуму стараюсь их обойти. Использую только когда не нашел другого способа.

      Про System.load() хорошая идея. Это как раз то, что можно было бы сделать в JDBCDriverProxyImpl. Я пробовал экспериментировать с System.load(), но ничего не получилось, из-за того, что библиотеку грузил в разных класслоадерах, а добавить JDBCDriverProxyImpl, придумал уже позже, когда уперся в DriverManager.

      Надо к этой функции вернуться.

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


      1. barker
        31.10.2016 08:55
        +3

        Ну просто не вы же первый такое придумали с загрузкой. Обычно распаковывают молча куда-нибудь внутрь условного home нужную dll/so и делают System.load. Для выгрузки всегда считалось, что если загрузивший classloader не используется и собран сборщиком, то библиотека должна отгрузиться. Но как на самом деле — я лично не проверял) Так что в целом инфа интересная.


    1. lany
      31.10.2016 17:00
      +1

      С выходом Java 9 — сразу до свидания!

      Насколько мне известно, в Java 9 ломается доступ к классам в недоступных пакетах. Если пакет доступен, то setAccessible работает как раньше. Во-всяком случае, этот тест прекрасно работает в 9-ea+138:


      import java.lang.reflect.*;
      import java.util.*;
      
      public class Test {
        public static void main(String[] args) throws Exception {
          Field usrPathsField = ClassLoader.class.getDeclaredField("usr_paths");
          usrPathsField.setAccessible(true);
          String[] paths = (String[]) usrPathsField.get(null);
          System.out.println(Arrays.toString(paths));
        }
      }


      1. apangin
        31.10.2016 17:37
        +2

        Всё верно. Со страшилками про Java 9 я переборщил :) В данном конкретном случае будет работать. ПОКА будет. Детали реализации, такие как приватные поля, могут измениться в любой момент, даже с минорным апдейтом.

        Кое-что в класслоадерах уже изменили в Java 9. Например, системный ClassLoader больше не наследник URLClassLoader. Но я встречал проекты, где просто кастовали системный ClassLoader, чтобы взять у него URLClassPath. И фокус с usr_paths из той же серии.


        1. lany
          31.10.2016 17:44
          +1

          С этим не поспоришь. Закладываясь на недокументированные детали реализации, мы подписываемся на постоянную их поддержку. Либо надо мониторить все изменения в этом классе и вовремя добавлять новые ветки, либо быть готовым, что всё сломается и виноват будешь только сам. Скользкая дорожка, в общем.


  1. apangin
    31.10.2016 03:30
    +4

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


    1. sergey-b
      31.10.2016 03:43
      +2

      Это решение я тоже рассматривал. Как более быстрый workaround я выбрал Windows Task Scheduler, а когда уже появилось время на эксперименты, очень хотелось увидеть именно как то, как библиотека выгружается.


      1. apangin
        31.10.2016 17:54

        Понятно. Что касается экспериментов, любопытно поисследовать, почему gc() + runFinalization() работал в Java 7, но перестал в Java 8. Как я уже писал в другой теме, сборки, вызванные System.gc() и дампом хипа, на уровне JVM принципиально не отличаются. Скорее всего, дамп помогал по другой причине, например, из-за таймингов. Не знаю, мне самому не удалось воспроизвести проблему: в JDK 8 System.gc() стабильно работал, и финализаторы вызывались. Вот, если бы в статье было про это — было бы интересно!


    1. izzholtik
      31.10.2016 10:45

      Как минимум, лаунчер:
      а. костыль
      б. затрудняет передачу параметров JVM пользователем
      в. требует написания :)


      1. Pngv
        31.10.2016 12:34
        +5

        А то, что предлагается, не костыли? Да и сколько надо было писать и эксперементировать :)

        Вот это — костыль:

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

        А если JVM оба раза откажется это делать, то что? Уж лучше лаунчер.


      1. lany
        31.10.2016 16:55
        +3

        По факту очень многие Java-приложения делают такой маленький нативный лаунчер (как минимум, все популярные IDE — IDEA, Eclipse, NetBeans). Параметры JVM записываются в какой-нибудь конфиг или передаются как-нибудь вроде -Jblahblah. Как минимум, это надёжнее: не всегда .jar на произвольной системе запутится как запускаемый файл. Сделать такой лаунчер совсем нетрудно, есть даже готовые генераторы этих лаунчеров.


        1. sergey-b
          31.10.2016 23:20

          Хотя этот подход применяется повсеместно, мне он не нравится тем, что это будет уже не программа на Java, а программа на C++ с примочкой на Java. Если я лаунчер на напишу на C#, то почему бы мне и в базу данных не слазить из C#? И зачем мне тогда JDBC-драйвер? Вот если бы этот лаунчер входил в JDK, тогда другое дело. В Eclipse такой плагин наверняка есть, но, видимо, он не входит в поставку JDT, потому что на глаза ни разу не попадался.


          1. apangin
            31.10.2016 23:37

            Если дело только в этом, можно и на Java лаунчер сделать. В JAR будет прописан Main-Class лаунчера, который запускает новый Java процесс с тем же JAR в classpath, но с другим Main классом.


            1. sergey-b
              31.10.2016 23:44

              Все же аргументы Java придется задавать отдельно, а иначе ни jmxremote, ни отладочный порт поднять не получится.


  1. lany
    31.10.2016 17:10
    +3

    Вот магия с ThreadLocal-ами — это самый ад здесь. Мало того что суровая завязка на реализацию. Реализация ThreadLocalMap абсолютно не потокобезопасная, потому что предполагается, что в неё никогда не залезает никто из чужого потока. Если во время вашего клинапа в другом потоке записывается какой-нибудь любой другой тредлокал, может в принципе много интересного произойти. Можно ведь и на рехэшинг напороться. Или вы не затрёте все записи, какие хотите затереть, или затрёте лишнюю запись.


    Вообще правильно Лёша Шипилёв говорит. Если вы сталкиваетесь с неразрешимой проблемой в Java, правильно — написать в мейлинг-листы OpenJDK, обсудить, предложить JEP, сделать патч, дождаться выхода следующей версии Java и радоваться. А хакать джаву неправильно, работоспособность вашей программы тогда гарантировать будет невозможно. Понятно, что это слишком идеалистическая картина мира, но всё-таки стоит иметь в виду такой вариант.


    1. sergey-b
      01.11.2016 00:14

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

      Что такое JEP?


      1. Pngv
        01.11.2016 01:44
        +1

        Про общение с командой OpenJDK поделитесь, пожалуйста, как это правильно делать

        1. Идем и находим нужный mail list
        2. Справшиваем там и/или ищем похожие проблемы в трекере

        Что такое JEP?

        JDK Enhancement-Proposal (JEP-2). Можно все там не читать. Это процесс для внесения новых фич и изменений в JDK.

        lany для того, чтобы предложить JEP, необходимо иметь учетную запись в трекере, а значит быть OpenJDK автором.


        1. lany
          01.11.2016 05:15

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


  1. Ilias
    02.11.2016 22:54

    прошу прощения за тупой вопрос — но зачем вообще надо было добиваться стопроцентной выгрузки длл-ки? просто чтобы не оставлять следов в temp каталоге?


    1. sergey-b
      02.11.2016 23:10

      Да.