{"draftJsState":{"blocks":[{"data":{},"depth":0,"entityRanges":[{"key":0,"length":12,"offset":52}],"inlineStyleRanges":[],"text":"Данная статья продолжает цикл моих переводов статей Jakob Jenkov об оптимизации Java приложений.","type":"unstyled","key":"e8hv6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":100,"style":"ITALIC"},{"length":9,"offset":221,"style":"ITALIC"},{"length":9,"offset":278,"style":"ITALIC"},{"length":9,"offset":357,"style":"ITALIC"},{"length":13,"offset":437,"style":"ITALIC"},{"length":19,"offset":479,"style":"ITALIC"}],"text":"Довольно часто приложения Java хранят объекты в структурах данных, содержащих java.util. Экземпляры ArrayList. При копировании объектов в этих структурах данных мы также должны повторять объекты, хранящиеся в экземплярах ArrayList. В этом руководстве по производительности Java ArrayList я подробнее рассмотрю производительность различных способов итерации ArrayList. В этом руководстве также будет рассмотрена производительность класса OpenArrayList - класса, который имитирует java.util.ArrayList, но разработанный с учетом производительности.","type":"unstyled","key":"6oqvo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Три способа перебора ArrayList","type":"header-two","key":"6lqa7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":78,"style":"ITALIC"}],"text":"В основном существует три различных способа перебора объектов, содержащихся в ArrayList:","type":"unstyled","key":"d5fpn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Используя цикл for","type":"unordered-list-item","key":"b4l4q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Используя цикл for-each","type":"unordered-list-item","key":"c34gn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Используя итератор.","type":"unordered-list-item","key":"ddc3b"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":66,"style":"ITALIC"},{"length":9,"offset":310,"style":"ITALIC"}],"text":"Разница в производительности между этими тремя способами итерации ArrayList невелика, но она небольшая, и она достаточно велика, чтобы, если ваш код критичен к производительности, вы могли бы получить этот почти бесплатный прирост производительности. Но сначала позвольте мне показать вам три способа итерации ArrayList.","type":"unstyled","key":"2s804"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Цикл for","type":"header-three","key":"6fj71"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":9,"style":"ITALIC"}],"text":"Итерация ArrayList с использованием стандартного цикла Java for выглядит следующим образом:","type":"unstyled","key":"27opk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"ArrayList arrayList = ...//get ArrayList from somewhere\n\nlong sum = 0; \nfor(int i=0, n=arrayList.size(); i < n; i++){\n Object element = arrayList.get(i);\n}","type":"blockquote","key":"dsqtb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":104,"style":"ITALIC"},{"length":9,"offset":155,"style":"ITALIC"}],"text":"Как вы можете видеть, цикл for использует стандартный счетчик для подсчета всех элементов, хранящихся в ArrayList. Каждый элемент получается из экземпляра ArrayList с помощью метода get().","type":"unstyled","key":"a8tq1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Цикл for-each","type":"header-three","key":"e72uq"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":90,"style":"ITALIC"}],"text":"Цикл for-each использует конструкцию for, добавленную в Java 5. Вот как выглядит итерация ArrayList с использованием цикла for-each:","type":"unstyled","key":"b5flp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"ArrayList arrayList = ...//get ArrayList from somewhere\n\nlong sum = 0;\nfor(Object obj : arrayList){\n ...\n}","type":"blockquote","key":"8d5dt"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Итератор","type":"header-three","key":"201b0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":23,"style":"ITALIC"},{"length":9,"offset":82,"style":"ITALIC"},{"length":9,"offset":119,"style":"ITALIC"}],"text":"Третий способ перебора ArrayList - использовать java.util.Итератор, полученный из ArrayList. Вот как выглядит итерация ArrayList с использованием итератора:","type":"unstyled","key":"f21ab"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"ArrayList arrayList = ...//get ArrayList from somewhere\n\nlong sum = 0;\nIterator iterator = arrayList.iterator();\nwhile(iterator.hasNext()) {\n Object element = iterator.next();\n}","type":"blockquote","key":"8n4vn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Производительность итератора ArrayList","type":"header-two","key":"7vv93"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":86,"style":"ITALIC"}],"text":"Чтобы измерить разницу в производительности итерации трех различных способов итерации ArrayList, я реализовал три различных метода тестирования с использованием Java Microbenchmark Harness. Код для этих контрольных показателей приведен в конце этого текста.","type":"unstyled","key":"dsehk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":106,"style":"ITALIC"}],"text":"Чтобы получить более точное представление о скорости итерации каждого метода, я измерил скорость итерации ArrayList из 10 и 100 элементов. Таким образом, я полагаю, я получил бы более детальную картину представления.","type":"unstyled","key":"9u0mv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":11,"style":"ITALIC"},{"length":9,"offset":201,"style":"ITALIC"}],"text":"Элементы в ArrayList - это длинные элементы, которые суммируются. Таким образом, контрольные показатели действительно измеряют как итерацию, так и суммирование 10 и 100 длинных элементов, хранящихся в ArrayList.","type":"unstyled","key":"f8jun"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Тесты были выполнены с использованием JDK 1.8.0_u60 на сервере Intel Core i7-4770 Haswell, который не делал ничего, кроме тестов. Тесты были выполнены с использованием значений по умолчанию JMH, что означает 20 итераций прогрева, 20 итераций и 10 форков каждой. Вот результаты тестирования (выходные данные JMH):","type":"unstyled","key":"bej01"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Benchmark Mode Cnt Score Error Units\nOpenArrayListBenchmark.jdkArrayList100SumUsingGet thrpt 200 15838998.503 Â± 1017.752 ops/s\nOpenArrayListBenchmark.jdkArrayList100SumUsingForEach thrpt 200 14068898.854 Â± 946.976 ops/s\nOpenArrayListBenchmark.jdkArrayList100SumUsingIterator thrpt 200 14069990.330 Â± 512.600 ops/s\nOpenArrayListBenchmark.jdkArrayList10SumUsingGet thrpt 200 77320532.538 Â± 7421.267 ops/s\nOpenArrayListBenchmark.jdkArrayList10SumUsingForEach thrpt 200 69926532.927 Â± 732112.779 ops/s\nOpenArrayListBenchmark.jdkArrayList10SumUsingIterator thrpt 200 69879781.630 Â± 727551.844 ops/s","type":"blockquote","key":"2lis8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":31,"style":"ITALIC"}],"text":"Как вы можете видеть, итерация ArrayList с использованием цикла for-each и итератора дает практически ту же производительность. Это было ожидаемо, так как цикл for-each, вероятно, компилируется компилятором Java в итерацию с использованием итератора.","type":"unstyled","key":"ar4oe"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":37,"style":"ITALIC"},{"length":9,"offset":154,"style":"ITALIC"},{"length":9,"offset":210,"style":"ITALIC"},{"length":9,"offset":271,"style":"ITALIC"}],"text":"Вы также можете видеть, что итерация ArrayList с использованием стандартного цикла Java for со счетчиком и получение каждого элемента путем вызова метода ArrayList get() выполняется примерно на 10% быстрее для ArrayList с 10 элементами и примерно на 12,5% быстрее, когда ArrayList содержит 100 элементов.","type":"unstyled","key":"a9d1d"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":252,"style":"ITALIC"}],"text":"Трудно точно сказать, почему существует такая разница в производительности. Частично разница, вероятно, вызвана созданием объекта-итератора для каждой итерации. Однако можно было бы ожидать, что накладные расходы будут выровнены (менее заметны), когда ArrayList содержит больше элементов. Но вместо этого, похоже, разница в производительности растет (с 10% при 10 элементах до 12,5% при 100 элементах). Это может быть вызвано более оптимизированным выполнением цикла процессором для версии for loop, но я не могу сказать наверняка.","type":"unstyled","key":"1t53p"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"OpenArrayList","type":"header-two","key":"7ktkj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":13,"offset":6,"style":"ITALIC"},{"length":9,"offset":49,"style":"ITALIC"},{"length":9,"offset":161,"style":"ITALIC"},{"length":13,"offset":206,"style":"ITALIC"}],"text":"Класс OpenArrayList - это очень простая имитация ArrayList, которую я реализовал, чтобы посмотреть, может ли он выполнять итерацию набора элементов быстрее, чем ArrayList. Вот сокращенная версия реализации OpenArrayList:","type":"unstyled","key":"37guv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public Object[] elements = null;\n\n public int capacity = 0;\n public int size = 0;\n\n public OpenArrayList(){\n }\n\n public OpenArrayList(int capacity){\n this.capacity = capacity;\n this.elements = new Object[capacity];\n }\n\n public OpenArrayList(Object[] elements){\n this.elements = elements;\n this.capacity = elements.length;\n }\n\n public void add(Object element){\n this.elements[this.size++] = element;\n }\n\n public boolean addIfCapacity(Object element){\n if(this.size < this.capacity){\n this.elements[this.size++] = element;\n return true;\n }\n return false;\n }\n}","type":"blockquote","key":"8q26l"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":13,"offset":77,"style":"ITALIC"},{"length":13,"offset":324,"style":"ITALIC"},{"length":9,"offset":389,"style":"ITALIC"}],"text":"Первое, на что следует обратить внимание, - это то, что все переменные-члены OpenArrayList являются общедоступными. Вот почему я назвал его \"Открытым\". Его переменные-члены открыты для внешнего мира. Я сделал переменные-члены общедоступными, чтобы вы могли напрямую обращаться к массиву элементов при повторении элементов в OpenArrayList. Это должно быть немного быстрее, чем вызов метода ArrayList get(), хотя JVM может оптимизировать вызов метода get().","type":"unstyled","key":"bqnho"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Еще одним преимуществом общедоступности массива элементов является то, что вы можете записывать в него или копировать из него с помощью System.arraycopy(), что очень быстро.","type":"unstyled","key":"72c18"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Производительность OpenArrayList","type":"header-two","key":"62rr2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":17,"style":"ITALIC"},{"length":13,"offset":90,"style":"ITALIC"},{"length":9,"offset":173,"style":"ITALIC"}],"text":"Как и в случае с ArrayList, я измерил суммирование объектов длиной 10 и 100, хранящихся в OpenArrayList. Тесты были выполнены с использованием той же настройки, что и тесты ArrayList.","type":"unstyled","key":"51nc8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":13,"offset":36,"style":"ITALIC"},{"length":9,"offset":79,"style":"ITALIC"}],"text":"Вот контрольные показатели итерации OpenArrayList (с контрольными показателями ArrayList ниже для удобства сравнения):","type":"unstyled","key":"am157"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Benchmark Mode Cnt Score Error Units\nOpenArrayListBenchmark.openArrayList100Sum thrpt 200 16040305.970 Â± 1490.153 ops/s\nOpenArrayListBenchmark.openArrayList10Sum thrpt 200 81301297.431 Â± 15104.301 ops/s\n\nOpenArrayListBenchmark.jdkArrayList100SumUsingGet thrpt 200 15838998.503 Â± 1017.752 ops/s\nOpenArrayListBenchmark.jdkArrayList100SumUsingForEach thrpt 200 14068898.854 Â± 946.976 ops/s\nOpenArrayListBenchmark.jdkArrayList100SumUsingIterator thrpt 200 14069990.330 Â± 512.600 ops/s\nOpenArrayListBenchmark.jdkArrayList10SumUsingGet thrpt 200 77320532.538 Â± 7421.267 ops/s\nOpenArrayListBenchmark.jdkArrayList10SumUsingForEach thrpt 200 69926532.927 Â± 732112.779 ops/s\nOpenArrayListBenchmark.jdkArrayList10SumUsingIterator thrpt 200 69879781.630 Â± 727551.844 ops/s","type":"blockquote","key":"491a5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":13,"offset":31,"style":"ITALIC"},{"length":9,"offset":87,"style":"ITALIC"}],"text":"Как вы можете видеть, итерация OpenArrayList выполняется примерно на 1% быстрее, когда ArrayList содержит 100 элементов, и примерно на 5% быстрее с 10 элементами. Почему именно существует такая разница в производительности, я не могу сказать наверняка. Тот факт, что производительность настолько близка, вероятно, является признаком того, что JVM оптимизировала вызов get(). Но все же интересно, что, по-видимому, существует большая разница в производительности для меньшего количества элементов.","type":"unstyled","key":"5kncm"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Производительность итератора","type":"header-two","key":"d5bf7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":99,"style":"ITALIC"},{"length":13,"offset":120,"style":"ITALIC"}],"text":"Вот эталонный код, используемый для измерения скорости итерации различных методов итерации как для ArrayList, так и для OpenArrayList.","type":"unstyled","key":"ce99h"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public class OpenArrayListBenchmark {\n\n @State(Scope.Thread)\n public static class BenchmarkState {\n public ArrayList jdkArrayList10 = new ArrayList<>();\n public ArrayList jdkArrayList100 = new ArrayList<>();\n public OpenArrayList openArrayList10 = new OpenArrayList(10);\n public OpenArrayList openArrayList100 = new OpenArrayList(100);\n\n @Setup(Level.Trial)\n public void toSetup() {\n Object[] elements = openArrayList10.elements;\n for(int i=0; i < openArrayList10.capacity; i++){\n elements[i] = new Long(i);\n jdkArrayList10.add(new Long(i));\n }\n openArrayList10.size = openArrayList10.capacity;\n elements = openArrayList100.elements;\n for(int i=0; i < openArrayList100.capacity; i++){\n elements[i] = new Long(i);\n jdkArrayList100.add(new Long(i));\n }\n openArrayList100.size = openArrayList100.capacity;\n }\n }\n\n @Benchmark\n @BenchmarkMode(Mode.Throughput)\n public long openArrayList10Sum(BenchmarkState state, Blackhole blackhole) {\n long sum = 0;\n Object[] elements = state.openArrayList10.elements;\n for(int i=0; i iterator = state.jdkArrayList10.iterator();\n while(iterator.hasNext()){\n sum += iterator.next().longValue();\n }\n blackhole.consume(sum);\n return sum;\n }\n\n @Benchmark\n @BenchmarkMode(Mode.Throughput)\n public long jdkArrayList100SumUsingIterator(BenchmarkState state, Blackhole blackhole) {\n long sum = 0;\n Iterator iterator = state.jdkArrayList100.iterator();\n while(iterator.hasNext()){\n sum += iterator.next().longValue();\n }\n blackhole.consume(sum);\n return sum;\n }\n}","type":"blockquote","key":"dptch"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"#code #java #performance ","type":"unstyled","key":"atqa2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"marker","key":"WNDXjpPHSVpT7mvrD3VR"}],"entityMap":{"0":{"data":{"href":"http://tutorials.jenkov.com/","url":"http://tutorials.jenkov.com/"},"mutability":"MUTABLE","type":"LINK"}}},"mentions":[]}