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

Question

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

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

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

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

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_multithreading решение необходимо было улучшить, чтобы 9X_threading оно соответствовало одновременным запросам на загрузку 9X_jre с одного и того же URL-адреса... и ограничивало 9X_concurrency фактическую "из Интернета" одиночной загрузкой 9X_concurrent (т. е. все другие запросы будут получать 9X_multithread ее из локальной файловой системы) . Итак, я 9X_threads синхронизировал весь метод:

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_javax запросу, но имеет проблему с производительностью, поскольку 9X_java предотвращает запуск всего метода другим 9X_jre потоком до его завершения. То есть, даже 9X_jre если файл может быть извлечен из локальной 9X_concurency ФС, доступ к getFileFromLocalFS(url) невозможен, пока метод выполняется 9X_thread другим потоком.

Улучшение производительности, предложенное 9X_concurency моим интервьюером, заключалось в синхронизации 9X_openjdk блока 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_jdk оптимизация работала, нужно убрать синхронизацию 9X_synchronized методов", т.е.:

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_concurrent и настоял на том, чтобы оставить обоих synchronized на месте.

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

u

undread

java

multithreading

concurrency

synchronized

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

Ответ #1

Ответ #2

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

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

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

I

IIapyc

Ссылка на ответ №2

M Mypcuk · Accepted Answer · 2023-11-16

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

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

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

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

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

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

Этот вопрос как-то 9X_synchronized решился. Это будет означать, что за кулисами 9X_jre уже существует некоторая поточно-безопасная 9X_multithreading конструкция для предотвращения такого состояния 9X_java гонки, следовательно, она должна использоваться 9X_threading getFileFromWeb(url) для решения проблемы множественных попыток 9X_multithread кэширования в первую очередь.
Или эта проблема 9X_concurency не была решена и отправной точкой был сломанный метод, поэтому 9X_multithread в первую очередь нужно исправить это, а 9X_synchronized не пытаться улучшить производительность. Если 9X_threads мы действительно попытаемся исправить это 9X_concurrency вне двух методов, т.е. в getFile, правильным будет 9X_concurrency только второй вариант, вызывающий оба метода 9X_jre внутри synchronized.

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

Например:

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