Может ли синхронизация внутреннего блока улучшить производительность уже синхронизированного метода?

Дана теоретическая система, в которой файлы 9X_jdk загружаются из Интернета, если они не найдены 9X_java в локальной системе, и предполагается:

  1. Механизм загрузки и извлечения/размещения из/в кэше (локальный файловая система) уже позаботились.
  2. Однопоточный и одиночный запрос на URL.

Я 9X_threads написал метод, использующий getFileFromLocalFS() и 9X_concurency getFileFromWeb() для реализации упрощенной 9X_concurrency логики кеширования:

public InputStream getFile(String url) { // #1
    InputStream retStream = getFileFromLocalFS(url);
    if (retStream != null) {
        return retStream;           
    }
    else {
        retStream = getFileFromLocalFS(url);
        if (retStream == null) {
            return getFileFromWeb(url);
        }
    }
    return retStream;
}

Затем это схематическое 9X_threads решение необходимо было улучшить, чтобы 9X_java оно соответствовало одновременным запросам на загрузку 9X_threading с одного и того же URL-адреса... и ограничивало 9X_threading фактическую "из Интернета" одиночной загрузкой 9X_synchronized (т. е. все другие запросы будут получать 9X_multithreading ее из локальной файловой системы) . Итак, я 9X_jre синхронизировал весь метод:

public synchronized InputStream getFile(String url) { // #2
    InputStream retStream = getFileFromLocalFS(url);
    if (retStream != null) {
        return retStream;           
    }
    else {
        retStream = getFileFromLocalFS(url);
        if (retStream == null) {
            return getFileFromWeb(url);
        }
    }
    return retStream;
}

Это, по сути, соответствует 9X_threads запросу, но имеет проблему с производительностью, поскольку 9X_concurrent предотвращает запуск всего метода другим 9X_javax потоком до его завершения. То есть, даже 9X_jre если файл может быть извлечен из локальной 9X_concurrency ФС, доступ к getFileFromLocalFS(url) невозможен, пока метод выполняется 9X_openjdk другим потоком.

Улучшение производительности, предложенное 9X_threads моим интервьюером, заключалось в синхронизации 9X_jdk блока getFileFromLocalFS(url):

public synchronized InputStream getFile(String url) { // #3
    InputStream retStream = getFileFromLocalFS(url);
    if (retStream != null) {
        return retStream;           
    }
    else {
        synchronized (this) { 
            retStream = getFileFromLocalFS(url);
            if (retStream == null) {
                return getFileFromWeb(url);
            }
        }
    }
    return retStream;
}

Я сказал "хорошо, но чтобы эта 9X_concurrent оптимизация работала, нужно убрать синхронизацию 9X_concurency методов", т.е.:

public InputStream getFile(String url) { // #4
    InputStream retStream = getFileFromLocalFS(url);
    if (retStream != null) {
        return retStream;           
    }
    else {
        synchronized (this) { 
            retStream = getFileFromLocalFS(url);
            if (retStream == null) {
                return getFileFromWeb(url);
            }
        }
    }
    return retStream;
}

Интервьюер не согласился 9X_java и настоял на том, чтобы оставить обоих synchronized на месте.

Какой 9X_concurency из них лучше работает в среде параллелизма? №3 9X_threads или №4? Почему?

6
0

java

multithreading

concurrency

synchronized
2
Общее количество ответов: 2

Ответ #1

Ответ на вопрос: Может ли синхронизация внутреннего блока улучшить производительность уже синхронизированного метода?

Кажется, происходит Cargo Cult Programming. Третий вариант напоминает 9X_javax Double-Checked Locking, но не улавливает сути. Но что еще более 9X_javax поразительно, первый вариант также напоминает Double-Checked 9X_openjdk Locking, вызывая getFileFromLocalFS(url) дважды без причины. И 9X_threading это отправная точка…

Ваше подозрение относительно 9X_openjdk «улучшения» интервьюера верно. Вложенная 9X_threads синхронизация бесполезна, и в лучшем случае 9X_thread оптимизатор JVM сможет ее устранить.

Однако 9X_thread ни одно из решений не рекомендуется. Тут 9X_jre гораздо более глубокая проблема. Во-первых, мы 9X_threads должны сосредоточиться на правильности, прежде чем обсуждать 9X_threading производительность.

Судя по всему, getFileFromLocalFS(url) должен 9X_concurrent найти локальную копию, если она существует, а 9X_threads не создать ее. Это было бы бессмысленно, если 9X_java бы никто никогда не создавал такие копии, и 9X_openjdk весь вопрос о перекрывающихся попытках кэширования 9X_openjdk был бы спорным, если этот метод не выполняет 9X_multithreading попытку кэширования. Таким образом, единственным 9X_jre другим задействованным методом, getFileFromWeb(url), должен 9X_thread быть тот, который создает локальную копию.

Это 9X_concurrent-programming означает, что между этими двумя методами 9X_thread существует скрытый протокол. getFileFromLocalFS(url) каким-то образом знает, как 9X_concurrency получить кешированный файл, созданный getFileFromWeb(url).

Это 9X_javax вызывает вопросы, например, что произойдет, если 9X_synchronized один поток находится в середине getFileFromWeb(url) создания 9X_javax кэшированной версии, а другой поток вызывает 9X_threading getFileFromLocalFS(url) для того же URL-адреса? Возвращает ли он 9X_threading входной поток в еще незавершенный локальный 9X_concurrent-programming файл? Есть две возможности:

  1. Этот вопрос как-то 9X_concurrent решился. Это будет означать, что за кулисами 9X_threads уже существует некоторая поточно-безопасная 9X_concurrent конструкция для предотвращения такого состояния 9X_concurrency гонки, следовательно, она должна использоваться 9X_concurrent getFileFromWeb(url) для решения проблемы множественных попыток 9X_multithread кэширования в первую очередь.

  2. Или эта проблема 9X_multithread не была решена и отправной точкой был сломанный метод, поэтому 9X_jre в первую очередь нужно исправить это, а 9X_threads не пытаться улучшить производительность. Если 9X_synchronized мы действительно попытаемся исправить это 9X_multithread вне двух методов, т.е. в getFile, правильным будет 9X_threading только второй вариант, вызывающий оба метода 9X_javax внутри synchronized.

В любом случае метод getFile не подходит 9X_jdk для решения проблемы. Проблемы параллелизма 9X_jre должны решаться с помощью скрытого протокола, который уже 9X_openjdk существует между двумя методами.

Например:

  • Если 9X_jre эти два метода используют сопоставление 9X_threading URL-адреса с локальным файлом, они должны 9X_javax использовать concurrent map и его атомарные операции обновления 9X_concurrent-programming для решения проблем параллелизма.

  • Если эти 9X_threading два метода используют схему сопоставления 9X_openjdk для преобразования URL-адреса в локальный 9X_openjdk путь, где должна быть копия, а метод getFileFromLocalFS(url) просто 9X_threads проверяет наличие файла, метод getFileFromWeb(url) должен создать 9X_openjdk файл с опцией CREATE_NEW для атомарной проверки наличия 9X_threads и создания, если нет, вместе с блокировкой 9X_concurrent файлов для предотвращения чтения другими 9X_thread потоками, пока кэширование все еще выполняется.

11
0

Ответ #2

Ответ на вопрос: Может ли синхронизация внутреннего блока улучшить производительность уже синхронизированного метода?

Оба они в основном (несколько затененные) версии 9X_javax double-checked locking pattern. Но, учитывая, что вызов getFileFromLocalFS(url) сам по себе может 9X_openjdk быть дорогостоящим (это вызов ввода-вывода, который 9X_threading всегда более затратен, чем операции в памяти), эта 9X_concurrent-programming форма шаблона на самом деле не идеальна. В 9X_concurrent-programming идеале реализация блокировки с двойной проверкой 9X_concurrent должна быть максимально "плотной", то 9X_thread есть две блокировки должны быть как можно 9X_multithread ближе друг к другу.

Дополнительная синхронизация 9X_threads в #3 (предложение интервьюера) создает дополнительные 9X_concurency накладные расходы и, что более важно, потенциально 9X_jre блокирует, когда в этом нет необходимости. "Производительность" — это 9X_threading широкий термин, который может означать разные 9X_concurency вещи для разных людей и в разных контекстах; но 9X_multithread эта дополнительная синхронизация может (вероятно?) повлиять 9X_concurrent-programming на наблюдаемую пропускную способность в зависимости от обстоятельств.

1
0