Производительность Java try / catch, рекомендуется ли сохранить то, что находится внутри предложения try, до минимума?

Учитывая, что у вас есть такой код:

doSomething() // this method may throw a checked a exception //do some assignements calculations doAnotherThing() //this method may also throw the same type of checked exception //more calls to methods and calculations, all throwing the same kind of exceptions. 

Теперь я знаю, что на самом деле производительность возникает при построении исключения, особенно для разворачивания стека. И я также прочитал несколько статей, указывающих на небольшой удар производительности при вводе блоков try / catch, но ни одна из статей, похоже, ничего не делает.

Мой вопрос заключается в том, рекомендуется ли поддерживать строки внутри try catch до минимума ?, то есть ТОЛЬКО внутри предложения try использовать строки, которые могут фактически генерировать исключение, которое вы ловите. Выполняется ли код внутри предложения try медленнее или приводит к потере производительности ?.

Но что более важно, что это лучшее / удобочитаемое решение, рассматривающее это:

 try { doSomething() // this method may throw a checked a exception //do some assignements calculations doAnotherThing() //this method may also throw the same type of checked exception //more calls to methods and calculations, all throwing the same kind of exceptions. } catch (MyCheckedException e) { //handle it } 

или :

 try { doSomething() // this method may throw a checked a exception } catch (MyCheckedException e) { //Store my exception in a Map (this is all running in a loop and I want it to continue running, but I also want to know which loops didn't complete and why) continue; } //do some assignements calculations try { doAnotherThing() // this method may throw a checked a exception } catch (MyCheckedException e) { //Store my exception in a Map (this is all running in a loop and I want it to continue running, but I also want to know which loops didn't complete and why) continue; } 

Это предполагает, что вы будете обрабатывать ВСЕ эти проверенные исключения точно так же, как, конечно.

    В вашем примере здесь реальное поражение производительности – это то, что оба doSomething () и doAnotherThing () генерируют исключения. Ввод блока try выполняется быстро, пока он не выдает исключение.

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

    Редактирование: я прочитал конец вашего комментария, вы предполагаете обработку одинаково, и в этом случае я бы поставил их оба в один и тот же блок try.

    Рекомендуется ли поддерживать линии внутри try catch до минимума?

    Нет. Не представляю, как можно думать, что длина блока try или даже любого блока может повлиять на производительность.

    Выполняется ли код внутри предложения try медленнее или приводит к потере производительности ?.

    Нет.

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

    Если вы беспокоитесь о производительности «try», наверняка нужно сделать код внутри максимально возможного?

    Я не уверен, какой из них медленнее, но не забывайте, что блок try – это stream управления. Вы должны сделать stream управления совпадающим с тем, что вы пытаетесь выполнить. Для меня выбор между

     try { // op 1. // op 2. / ... // op n. } catch ( MyCheckedException error ) { // handle any `MyException` in op 1, 2 ... n. } 

    и sepearate блоки catch для каждого из них – это главным образом решение о том, хочу ли я выполнять различную обработку для каждого op, продолжайте выполнение до тех пор, пока op n зависеть от ошибок или не попытается выполнить их все и не сработает при первой ошибке.

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

    Наличие try-блоков должно иметь в основном нулевой эффект производительности в любой порядочной JVM. Настоящий хит приходит, когда на самом деле происходит исключение.

    Вы можете прочитать эту статью, чтобы получить представление о том, как JVM реализует обработку исключений в байт-коде: она создает «таблицы исключений», которые отображают регионы кода для блокировки / окончательных блоков, поэтому:

    • Байт-код для блока try такой же, как для стандартного блока {}
    • Единственная дополнительная стоимость в случае не бросания – это то, что в таблицу загружена «таблица исключений».

    Конечно, когда генерируется исключение, происходит много работы с стеком, поэтому у него будет стоимость. Во всяком случае, это не так плохо, как с SEH (исключения .NET).

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

    Количество кода в блоке try не вызывает замедление, но это делает удачный блок catch. Но если вы не пытаетесь написать настоящий высокопроизводительный код, я бы не стал беспокоиться об этом.

    Сохранение минимального количества блоков try / catch немного улучшит производительность, но перемещение работы не будет иметь особого значения, за исключением работы, которая будет пропущена из-за созданного исключения.

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

    Однако вы также должны учитывать разницу в семантике. В первом примере, если doSomething() выдает исключение, doAnotherThing() не будет запущен. Во втором примере (при условии, что обработчик улова не возвращается), doAnotherThing() будет запущен.

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

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

    Смотрите исходный код и результаты тестов здесь .

    Я не уверен, что внутри блока try производительность может быть медленной, но я знаю, что производительность ex.getStackTrace() очень медленная, потому что она ex.getStackTrace() весь ваш стек команд, и вы должны быть осторожны с этим.

    Давайте будем гением компьютера.