АСУ ТП в облаке — быстрая разработка проектов

[Владимир Ситников]

по Вашему настоянию его я убрал из ссылочного примера, в который раз я говрю что пользуюсь этим https://netbeans.org/kb/docs/java/pr...-intro_ru.html а не вычитанием времени в проекте.

Я понимаю, что вы пользуетесь netbeans profiler, но это никак вас не оправдывает.
Моё настояние -- переписать пример на JMH. Можете?
Я, вот, переписал, и получил ожидаемый результат: разницы между buffer и builder в конкретном примере не нашлось.

Netbeans profiler -- это инструмент анализа, когда есть что анализировать. А у вас и анализировать пока нечего.
Вот jmh тест уже можно анализировать. И искать причины "почему работает с одинаковой скоростью".

представте когда формируешь svg-строки суточного графика температур, строки получаются очень длинными, конечно может и не 10М, но я не проверял

Общий объём SVG в 10 мегабайт -- верю. Кстати, я там ошибся, и строки у вас 1e7*5*2==100 мегабайт. Но и в 100 мегабайт html кода даже поверить могу.
Но, ведь, и надёжнее будет не пытаться всю строку в памяти размещать, а использовать потоковые механизмы.
Сгенерировали 1 мегабайт, записали его в файл и т.п.

Но, ведь, у вас не возникнет сомнения, что "строки на 100-1000 байт" встречаются гораздо чаще? Каждое выводимое сообщение, строка в логе, и т.п.

Оптимизировать процесс, который занимает меньше секунды и строит строку на 50 миллионов символов? И много там наоптимизируете?
А сколько при этом занимает выборка данных, на основе которых строится этот многомегабайтный отчёт?
Неужели гораздо быстрее этой самой секунды, что "1 секунда" оказалась узким местом?

признаюсь в английском не так силен, но почему http://cr.openjdk.java.net/~shade/8085796/notes.txt используется билдер, а не буффер. Кстати, нетбинс тоже оракловское детище, и если специалист сравнивает с openjdk то наверное с самым скоростным способом стандартного API, а не аутсайдеров

Да, без английского, немного тяжко.
Во-первых, между Buffer и Builder разницы никакой нет.
Во-вторых, даже если она и есть, то объём статьи (и время, требуемое для получения замеров) разрастётся офигеть как и прочитать станет вообще невозможно.
Да и написать такое будет гораздо сложнее (нужно же правильно вставить кучу цифр).
В третьих, специалист сравнивает не только "с самым скоростным" (хотя, конечно, имеет сравнивать именно с самым скоростным), но и с тем способом, который openjdk использовала _до этого_. Вот взять текущую openjdk 8. Она компилирует сложение строк через StringBuilder. Значит ли это, что Builder "самый скоростной"? Возможно. Значит ли это, что "Buffer капец какой тормозной"? Вовсе не значит.

Как это отменяет слова "чел, который ещё год назад пользовался стрингбуффером, вместо билдера"?
Как это отменяет то, что "замеры нужно делать на jmh"?

В общем:
1) Пользуйтесь jmh. Там реально никаких сложностей нет
2) Не наезжайте на других по вопросам Builder vs Buffer

[Владимир Ситников]

вот есть авторитетный замерщик ему можно верить

Опять перевираете.
Полностью звучит так: вот есть способ проверить.

Ну, давайте, я проверю. Вам от этого легче станет?
Вот если вы запустите нормальный jmh тест, а не то убожество с однократным запуском, то это уже другое дело. Может, глаза откроются.

Расчехляем jmh, и получаем, что скорость выполнения одна и та же.

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.TimeUnit;

@Fork(value = 3, jvmArgsPrepend = {"-Xms2g", "-Xmx2g"})
@Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
@Warmup(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
@State(Scope.Thread)
@Threads(1)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class StringConcat {

  @Benchmark
  public String builder() {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 1e7; i++) {
      sb.append("Irbis");
    }
    return sb.toString();
  }

  @Benchmark
  public String buffer() {
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < 1e7; i++) {
      sb.append("Irbis");
    }
    return sb.toString();
  }

  public static void main(String[] args) throws RunnerException {
    Options opt = new OptionsBuilder()
        .include(StringConcat.class.getSimpleName())
        //.addProfiler(GCProfiler.class)
        .detectJvmArgs()
        .build();

    new Runner(opt).run();
  }

}

# JMH 1.11.2 (released 92 days ago, please consider updating!)
# VM version: JDK 1.8.0_60, VM 25.60-b23
# VM invoker: /Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home/jre/bin/java
# VM options: -Xms2g -Xmx2g -Didea.launcher.port=7532 -Didea.launcher.bin.path=/Applications/IntelliJ IDEA 15.app/Contents/bin -Dfile.encoding=UTF-8
# Warmup: 10 iterations, 1 s each
# Measurement: 10 iterations, 1 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: org.postgresql.util.StringConcat.buffer

# Run progress: 0,00% complete, ETA 00:02:00
# Fork: 1 of 3
# Warmup Iteration   1: 504,478 ms/op
# Warmup Iteration   2: 167,282 ms/op
# Warmup Iteration   3: 156,712 ms/op
# Warmup Iteration   4: 142,019 ms/op
# Warmup Iteration   5: 130,716 ms/op
# Warmup Iteration   6: 132,175 ms/op
# Warmup Iteration   7: 130,494 ms/op
# Warmup Iteration   8: 128,751 ms/op
# Warmup Iteration   9: 128,376 ms/op
# Warmup Iteration  10: 135,927 ms/op
Iteration   1: 142,503 ms/op
Iteration   2: 126,427 ms/op
Iteration   3: 121,183 ms/op
Iteration   4: 123,705 ms/op
Iteration   5: 134,235 ms/op
Iteration   6: 122,471 ms/op
Iteration   7: 124,813 ms/op
Iteration   8: 127,109 ms/op
Iteration   9: 122,452 ms/op
Iteration  10: 128,862 ms/op

# Run progress: 16,67% complete, ETA 00:01:50
# Fork: 2 of 3
# Warmup Iteration   1: 290,340 ms/op
# Warmup Iteration   2: 133,337 ms/op
# Warmup Iteration   3: 123,226 ms/op
# Warmup Iteration   4: 131,857 ms/op
# Warmup Iteration   5: 128,725 ms/op
# Warmup Iteration   6: 129,772 ms/op
# Warmup Iteration   7: 123,170 ms/op
# Warmup Iteration   8: 122,863 ms/op
# Warmup Iteration   9: 129,920 ms/op
# Warmup Iteration  10: 120,862 ms/op
Iteration   1: 122,446 ms/op
Iteration   2: 124,428 ms/op
Iteration   3: 133,191 ms/op
Iteration   4: 119,475 ms/op
Iteration   5: 126,896 ms/op
Iteration   6: 123,963 ms/op
Iteration   7: 134,483 ms/op
Iteration   8: 133,446 ms/op
Iteration   9: 127,896 ms/op
Iteration  10: 125,156 ms/op

# Run progress: 33,33% complete, ETA 00:01:28
# Fork: 3 of 3
# Warmup Iteration   1: 285,805 ms/op
# Warmup Iteration   2: 130,223 ms/op
# Warmup Iteration   3: 122,691 ms/op
# Warmup Iteration   4: 132,281 ms/op
# Warmup Iteration   5: 130,149 ms/op
# Warmup Iteration   6: 129,617 ms/op
# Warmup Iteration   7: 125,146 ms/op
# Warmup Iteration   8: 125,089 ms/op
# Warmup Iteration   9: 133,226 ms/op
# Warmup Iteration  10: 125,234 ms/op
Iteration   1: 119,962 ms/op
Iteration   2: 126,932 ms/op
Iteration   3: 132,335 ms/op
Iteration   4: 131,525 ms/op
Iteration   5: 127,541 ms/op
Iteration   6: 121,408 ms/op
Iteration   7: 119,892 ms/op
Iteration   8: 139,716 ms/op
Iteration   9: 121,877 ms/op
Iteration  10: 125,758 ms/op


Result "buffer":
  127,070 ±(99.9%) 3,904 ms/op [Average]
  (min, avg, max) = (119,475, 127,070, 142,503), stdev = 5,844
  CI (99.9%): [123,165, 130,974] (assumes normal distribution)


# JMH 1.11.2 (released 92 days ago, please consider updating!)
# VM version: JDK 1.8.0_60, VM 25.60-b23
# VM invoker: /Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home/jre/bin/java
# VM options: -Xms2g -Xmx2g -Didea.launcher.port=7532 -Didea.launcher.bin.path=/Applications/IntelliJ IDEA 15.app/Contents/bin -Dfile.encoding=UTF-8
# Warmup: 10 iterations, 1 s each
# Measurement: 10 iterations, 1 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: org.postgresql.util.StringConcat.builder

# Run progress: 50,00% complete, ETA 00:01:06
# Fork: 1 of 3
# Warmup Iteration   1: 177,462 ms/op
# Warmup Iteration   2: 127,427 ms/op
# Warmup Iteration   3: 116,823 ms/op
# Warmup Iteration   4: 128,042 ms/op
# Warmup Iteration   5: 126,923 ms/op
# Warmup Iteration   6: 123,174 ms/op
# Warmup Iteration   7: 125,599 ms/op
# Warmup Iteration   8: 127,271 ms/op
# Warmup Iteration   9: 128,333 ms/op
# Warmup Iteration  10: 114,842 ms/op
Iteration   1: 128,124 ms/op
Iteration   2: 117,573 ms/op
Iteration   3: 126,854 ms/op
Iteration   4: 127,813 ms/op
Iteration   5: 116,706 ms/op
Iteration   6: 120,092 ms/op
Iteration   7: 122,443 ms/op
Iteration   8: 124,191 ms/op
Iteration   9: 125,831 ms/op
Iteration  10: 121,483 ms/op

# Run progress: 66,67% complete, ETA 00:00:44
# Fork: 2 of 3
# Warmup Iteration   1: 175,898 ms/op
# Warmup Iteration   2: 129,208 ms/op
# Warmup Iteration   3: 125,624 ms/op
# Warmup Iteration   4: 117,651 ms/op
# Warmup Iteration   5: 129,693 ms/op
# Warmup Iteration   6: 122,625 ms/op
# Warmup Iteration   7: 117,697 ms/op
# Warmup Iteration   8: 118,748 ms/op
# Warmup Iteration   9: 129,949 ms/op
# Warmup Iteration  10: 129,812 ms/op
Iteration   1: 122,881 ms/op
Iteration   2: 120,961 ms/op
Iteration   3: 116,294 ms/op
Iteration   4: 129,627 ms/op
Iteration   5: 122,964 ms/op
Iteration   6: 117,850 ms/op
Iteration   7: 124,518 ms/op
Iteration   8: 169,902 ms/op
Iteration   9: 124,100 ms/op
Iteration  10: 124,082 ms/op

# Run progress: 83,33% complete, ETA 00:00:22
# Fork: 3 of 3
# Warmup Iteration   1: 178,994 ms/op
# Warmup Iteration   2: 129,012 ms/op
# Warmup Iteration   3: 133,074 ms/op
# Warmup Iteration   4: 123,572 ms/op
# Warmup Iteration   5: 137,259 ms/op
# Warmup Iteration   6: 125,592 ms/op
# Warmup Iteration   7: 125,917 ms/op
# Warmup Iteration   8: 125,565 ms/op
# Warmup Iteration   9: 134,758 ms/op
# Warmup Iteration  10: 123,280 ms/op
Iteration   1: 121,962 ms/op
Iteration   2: 121,457 ms/op
Iteration   3: 129,659 ms/op
Iteration   4: 136,555 ms/op
Iteration   5: 130,896 ms/op
Iteration   6: 136,405 ms/op
Iteration   7: 128,355 ms/op
Iteration   8: 138,604 ms/op
Iteration   9: 130,620 ms/op
Iteration  10: 126,581 ms/op


Result "builder":
  126,846 ±(99.9%) 6,624 ms/op [Average]
  (min, avg, max) = (116,294, 126,846, 169,902), stdev = 9,915
  CI (99.9%): [120,222, 133,470] (assumes normal distribution)

# Run complete. Total time: 00:02:12

Benchmark             Mode  Cnt    Score   Error  Units
StringConcat.buffer   avgt   30  127,070 ± 3,904  ms/op
StringConcat.builder  avgt   30  126,846 ± 6,624  ms/op

Т.е. различие в 0.2мс при том, что статистическая ошибка порядка 10мс.

[Владимир Ситников]

по поводуэто было сказано в контексте генерации кода на SCL|ST а не к Яве да и имело отношение к другому форумчанину, так что анализ моей воспитанности не Ваш конек

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

^^^ Вот тут было нехорошо сказано.

В части "генерации кода на SCL|ST", конечно, с вами соглашусь. Слова класса "вместо ST'шного FOR будет новомодный облачный ЦИКЛ", конечно, ни разу не объясняют чем "облачный FOR" будет лучше простого. Как его ни называй, он же всё равно циклом останется. Но, может, и удастся что-нибудь придумать. Новомодное мыло может оказаться круче старого шила.

[Владимир Ситников]

в общем: я доверяю команде разработчиков нетбинс против одного Алексея,продвигающего опенпродукт

Ась?
Вы понимаете, что java машин всего 3-4 штуки в МИРЕ? Я говорю не про наколеночные поделки, а про пригодные к использованию.
Oracle JDK основывается на OpenJDK.
Это знаете?

Поймите меня: я не заставляю вас бросить веру в NetBeans.
И не заставляю "поверить в Алексея".
Я говорю лишь то, что напряжение нужно измерять вольтметром, а тесты на производительность строить на основе JMH.
Алексей на примерах (которые вы на своём компьютере повторить можете) красочно рассказывает почему без JMH ничего не получится.

анализ показывает, что рекомендуемый класс работает быстрее

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

я доверяю команде разработчиков нетбинс

Нравятся вам рекомендации NetBeans -- не вопрос.
Но это не повод других тыкать носом в "builder buffer".