Java Specialist
Блог о памяти, сборщике мусора, многопоточности и производительности в java
Содержание
понедельник, 16 апреля 2012 г.
Измерение времени и засыпание потоков
System.currentTimeMillis()
System.nanoTime()
Второй метод использует специальные счетчики, не связанные с системными часами (хотя на некоторых платформах он и может быть реализован через них, но это скорее исключение нежели правило). Формально System.nanoTime() возвращает наносекунды, но последовательные вызовы этого метода вряд ли дадут точность больше микросекунд. На большинстве систем данный метод будет возвращать неубывающие значения, для чего ему может потребоваться внутренняя синхронизация, если он будет вызываться на разных процессорах. Поэтому производительность этого метода очень сильно зависит от железа, и на некоторых машинах запрос к этому методу может легко занимать больше времени, чем запрос к System.currentTimeMillis() [2].
Учитывая, относительность времени, возвращаемого данным методом, его невозможно использовать, скажем, для измерения времени передачи сообщения от одного бокса к другому. Хотя конечно можно измерить время полного round-trip, вычесть время проведенное на второй машине и поделить на два. Однако если у вас распределенное приложение и вам очень важно мереть время затраченное на определенных операциях, которые распределены по разным боксам, то вы можете написать нативный метод, который будет возвращать абсолютное время с большей точность. Я видел такой подход в одном из проектов, с которыми мне приходилось интегрироваться.
Thread.sleep() / Object#wait()
С помощью данных методов можно попросить текущий поток уснуть на определенное количество миллисекунд. Точность просыпания будет зависеть от размера интервала прерываний на вашей ОС. На Windows это обычно 10 мс (но на некотором железе может быть и 15 мс [4]). Однако длина этого интервала может быть изменена даже стандартными средствами java. Данное переключение происходит автоматически, если вы просите заснуть любой поток на время не кратное, текущему интервалу прерываний. Причем, когда данный поток проснется, ОС вернется обратно к штатному режиму.
Как замерить время выполнения
Зачастую требуется узнать, сколько времени выполняется тот или иной код. Иногда требуется замерить время выполнения метода или какой-то задачи. В данной статье мы расскажем вам принципы замера времени в Java и покажем лучшие практики для конкретных задач.
Замер времени с помощью currentTimeMills()
Это довольно простой способ измерить время. Метод System.currentTimeMillis() вернёт вам текущее время в миллисекундах. Его потребуется вызвать до выполнения нужной задачи и после, а затем вычислить разницу. В итоге мы узнаем время выполнения в миллисекундах:
При работе с данным методом следует учитывать его специфику: System.currentTimeMillis() показывает текущее время, основываясь на системных часах и может выдавать некорректный результат.
Замер времени с помощью nanoTime()
Ещё один метод для получения текущего времени это System.nanoTime(). Как следует из названия, этот метод возвращает время с точностью до нансекунд. Также работа этого метода не зависит от системных часов.
Он используется аналогично:
Для получения значения в миллисекундах результат можно разделить на 1000:
Важно: Хотя метод nanoTime() может возвращать время в наносекундах, он не гарантирует, что значения между его вызовами будут обновляться с точностью до наносекунд.
Но всё же это более приемлемый вариант, чем System.currentTimeMillis().
Замер времени с помощью Instant и Duration
В Java 8 добавили новый java.time API. В частности, ля измерения времени подойдут два новых класса – Instant и Duration. Оба эти класса иммутабельны.
Instant обозначает момент времени с начала эпохи Unix (1970-01-01T00:00:00Z). Для создания момента мы используем метод Instant.now(). После того, как мы создали два момент, вычислим разницу в миллисекундах:
Рекомендуется использовать именно этот подход в Java 8 и выше.
Замер времени выполнения с помощью StopWatch
StopWatch – это класс из библиотеки Apache Commons Lang. Он работает как секундомер. Для его использования сначала требуется подключить библиотеку к проекту:
Теперь создадим экземпляр StopWatch. Затем начнём отсчёт с помощью метода start() и окончим отсчёт с помощью метода stop():
StopWatch удобно использовать тогда, когда в проекте уже подключена данная библиотека.
Исходный код
Заключение
В данной статье мы разобрали простые методы замера времени выполнения в Java. Для простых замеров можно использовать все вышеперечисленные методы, кроме currentTimeMillis (из-за того, что он зависит от системных часов).
Приёмы и хитрости начинающего Java-программиста
Авторизуйтесь
Приёмы и хитрости начинающего Java-программиста
эксперт по разработке ПО компании «Рексофт»
В этой статье собрана небольшая коллекция практик, трюков и подсказок, с помощью которых вы сэкономите своё время при изучении Java и написании кода на этом языке программирования.
Организация работы
Чистый код
В крупных проектах на первый план выходит не создание нового кода, а поддержка существующего, поэтому очень важно с самого начала его правильно организовать. При разработке нового приложения всегда помните о трех основных принципах чистого и поддерживаемого кода:
Работа с ошибками
Stack Trace (Трассировка стека)
Выявление ошибок — это, пожалуй, самая трудоемкая часть процесса разработки на Java. Трассировка стека позволяет вам точно отслеживать, где именно в проекте возникла ошибка или исключение (exception).
NullPointerException
Исключения, возникающие из-за null значений ( NullPointerException ), довольно часто появляются при попытке вызвать метод у несущестующего объекта.
Возьмем для примера следующий код:
Прим. перев. А вот пример от меня как переводчика материала:
Дата и Время
System.currentTimeMillis или System.nanoTime?
В Java есть два стандартных способа проведения операций со временем, и не всегда ясно, какой из них следует выбрать.
Метод System.currentTimeMillis() возвращает текущее количество миллисекунд с начала эры Unix в формате Long. Его точность составляет от 1 до 15 тысячных долей секунды в зависимости от системы.
Метод System.nanoTime() имеет точность до одной миллионной секунды (наносекунды) и возвращает текущее значение наиболее точного доступного системного таймера.
Таким образом, метод System.currentTimeMillis() лучше применять для отображения и синхронизации абсолютного времени, а System.nanoTime() для измерения относительных интервалов времени.
Валидация Даты из строки
Пример его использования:
Строки
Оптимизация строки
Для конкатенации (сложения) строк в Java используется оператор «+», для примера, в цикле for новый объект может создаваться для каждой новой строки, что приводит к потере памяти и увеличению времени работы программы.
Необходимо избегать создания Java строк через конструктор, пример:
Одинарные и двойные кавычки
Что ты ожидаешь в результате выполнения этого кода?
Казалось бы, строка должна возвращать «HaHa», но на самом деле это будет «Ha169».
Двойные кавычки обрабатывают символы как строки, но одинарные кавычки ведут себя иначе. Они преобразуют символьные операнды ( ‘H’ и ‘a’ ) в целые значения посредством расширения примитивных типов — получается 169.
Математика
Float или Double?
Программисты часто не могут выбрать необходимую точность для чисел с плавающей запятой. Float требует всего 4 байта, но имеет только 7 значащих цифр, а Double в два раза точнее (15 цифр), но в два раза прожорливее.
Фактически, большинство процессоров могут одинаково эффективно работать как с Float, так и с Double, поэтому воспользуйтесь рекомендацией Бьорна Страуструпа (автор языка С++):
Выбор правильной точности для решения реальных задач требует хорошего понимания природы машинных вычислений. Если у вас его нет, либо посоветуйтесь с кем-нибудь, либо изучите проблему самостоятельно, либо используйте Double и надейтесь на лучшее.
Проверка на нечетность
Можно ли использовать этот код для точного определения нечетного числа?
Он не только решает проблему отрицательных чисел, но и работает более производительно, чем предыдущий метод. Арифметические и логические операции выполняются намного быстрее, чем умножение и деление.
Возведение в степень
Возвести число в степень можно двумя способами:
Использование библиотечной функции рекомендуется только в случае крайней необходимости, например, в случае дробной или отрицательной степени.
Простое умножение в Java работает в 300-600 раз эффективнее, кроме того, его можно дополнительно оптимизировать:
JIT оптимизация
Код Java обрабатывается с использованием JIT-компиляции: сначала он транслируется в платформенно-независимый байт-код, а затем в машинный код. При этом оптимизируется все возможное, и разработчик может помочь компилятору создать максимально эффективную программу.
В качестве примера рассмотрим две простые операции:
Давайте измерим время выполнения каждого из них:
Запустив этот код несколько раз, мы получим примерно следующее:
Схема очевидна: группировка переменных в круглые скобки ускоряет работу программы. Это связано с генерацией более эффективного байт-кода при умножении одинаковых значений.
Вы можете узнать больше об этом эксперименте здесь. Или можете провести свой собственный тест, используя онлайн-компилятор Java.
System.nanoTime() против System.currentTimeMillis()
Java предоставляет два метода для определения времени операций: System.nanoTime () и System.currentTimeMillis (). Но какой из них следует использовать в каких условиях? И что более эффективно?
На первый взгляд может показаться, что следует использовать nanoTime (), поскольку он дает более точное значение времени (в нано секундах по сравнению с миллисекундами, которые возвращает другой метод). Но всегда ли эффективно на процессоре использовать nanoTime? Давайте посмотрим на плюсы и минусы использования обоих методов:
System.currentTimeMillis ()
public static long currentTimeMillis ()
// Возвращает текущее время в миллисекундах.
Всегда возвращает абсолютное время, прошедшее с начала эпохи (число в миллис с 1 января 1970 г. 00:00).
Потребляет меньше тактов для выполнения (около 5-6 тактовых процессоров).
Дает более точное время, так как точка отсчета (эпоха) является фиксированной.
System.nanoTime ()
public static long nanoTime ()
// Возвращает текущее значение высокого разрешения работающей JVM
// источник времени, в наносекундах.
Минусы:
Отраженный результат не имеет фиксированной контрольной точки. Согласно документации Java,
Возвращаемое значение представляет наносекунды, так как некоторые фиксированные
но произвольное время (возможно, в будущем, поэтому значения могут быть отрицательными).
В зависимости от системы может потребоваться более 100 циклов процессора.
Давайте посмотрим на рабочий пример, чтобы сравнить результаты этих двух функций:
class Main <
public static void main(String[] args)
<
long nano_startTime = System.nanoTime();
long millis_startTime = System.currentTimeMillis();
// Perform the work whose time is to be measured
someFunction();
long nano_endTime = System.nanoTime();
long millis_endTime = System.currentTimeMillis();
Если коротко: System.currentTimeMillis используем если надо получить временную точку и он потокобезопасен; System.nanoTime используем для микробенчмарков, он не потокобезопасен.
Если требуется высокая точность, то выбор java как инструмента разработки весьма странен.
Ответ на пост «Похоже наказания из рос-армии добрались по интернету и до обычной жизни»
Главное, чтобы работало.
Похоже наказания из рос-армии добрались по интернету и до обычной жизни
Я работаю в школе программирования. Если студенты нарушают правила, то в наказание им заменяют клавиатуры на это.
Бесплатно помогаю пикабушникам учить программирование, часть 23: «Как сохранять спокойствие и не выгорать.»
Я продолжаю отвечать на вопросы из комментариев своих подписчиков. Задавая их вы помогаете проекту развиваться. Началось всё здесь
Нижеописанные советы основаны исключительно на личном опыте.
1. Не работайте сверхурочно.
Этим очень часто грешат на галерах в аутсорсе. Некоторые «эффективные менеджеры» могут позвонить в субботу утром потому, что образовалась ну очень срочная задача, которую совсем никак нельзя откладывать. Доверительно относиться к таким ситуациям не стоит.
В таких случаях никого не волнует ваше состояние. Крайне неразумно разменивать свою вовлеченность в программирование на полное отвращение даже к самым интересным задачам из-за таких персонажей.
2. При малейших признаках выгорания отдыхайте до того, как устали.
3. Общайтесь с кем-то вне работы на нерабочие темы.
4. Освобождайте долговременную память записывая запланированные задачи.
Это очень помогает снизить утомляемость.
5. Ставьте свой комфорт в приоритет.
Всегда помните: работодателей очень много, а такой красивый(вая) вы у мамы один(одна).
6. Не бойтесь новых технологий.
Сейчас рынок разработки очень быстро меняется. Нужно учиться новому почти каждый день, чтобы оставаться на плаву. Если не следит за трендами, то в итоге вы не только невзлюбите свою работу, но и просто останетесь без неё!
7. Фиксируйте все то, что с вами происходит.
Ведите краткий список всех событий, происходивших на вашей работе, которые показались вам значимыми. Память очень ненадежна потому, что она часто притупляет негативный и травмирующий опыт.
Мой канал в Telegram, где я помогаю новичкам: https://t.me/LearnRubyForPikabu
Уже 37 моих подписчиков дошли до получения работы.
Добро пожаловать всем желающим.
Go gopher милая вязаная игрушка
Создавать этого малыша было одно удовольствие, хоть это и на первый взгляд просто «синяя сосиска с ушами» ))))
При создании gopher я использовала различные материалы как: пряжа Пехорка «цветное кружево», крючок для вязания 0,7мм., синтепон, полимерную глину для зубов, немного пластмассы для очков авиаторской шапки, ну и конечно хорошее настроение))))
Этот пост является логическим продолжением моего предыдущего поста о борьбе с синдромом самозванца. Дополнить эту историю меня побудили комментарии, посыл которых очень неоднозначный.
Я продолжаю отвечать на вопросы из комментариев своих подписчиков. Задавая их вы помогаете проекту развиваться. Началось всё здесь
Немного о причинах
Это происходит не только в IT сфере, но рассказывать приводить примеры я буду именно про разработчиков. Просто потому, что здесь у меня очень много релевантного опыта.
Очень часто разработчик связывает свои успехи со случайным удачным стечением обстоятельств.
Это явление довольно популярное. Например разработчик успешно прошел собеседование потому, что задачи были легкие или тимлид поленился заморачиваться над сложными вопросами. Или же сложную задачу получилось решить легко и быстро потому, что на прошлой работе была похожая ситуация.
Разберем каждый случай отдельно.
Разработчик успешно прошел собеседование потому, что задачи были легкие.
Тимлид поленился заморачиваться над сложными вопросами, разработчик легко ответил на не сложные, попал в команду и теперь у него неловкое чувство.
Во-вторых: его, вполне могло устроить ваше резюме и фрагменты вашего кода, которые он видел до собеседования. Поэтому он отнесся к собеседованию как к необходимой бюрократии, легонько прощупал почву и убедился что заявленные качества соответствуют действительности.
В третьих: тимлид, чаще всего, гораздо более компетентен чем среднестатистический кодерок в его подчинении. Поэтому его мнение в кадровых и технических моментах более весомо чем ваши переживания. Посмотрите его код, убедитесь что он более опытен чем вы, и просто доверьтесь его выбору.
Сложную задачу получилось решить легко и быстро потому, что на прошлой работе была похожая ситуация.
Посмотрите на ситуацию с позиции бизнеса. У вас обнаружилась проблема, которую нужно обязательно решить. Вы нанимаете разработчика. Разработчик сталкивался с этой задачей на предыдущей работе, поэтому всё получилось быстрее и легче чем ожидалось. Плюсы есть, минусов нету.
Немного о более ранних причинах
Очень часто люди себя недооценивают потому, что ошибаются. В их понимании наличие ошибок это неопровержимый факт их низкой компетенции.
Мой канал в Telegram, где я помогаю новичкам изучать веб-разработку: https://t.me/LearnRubyForPikabu
Уже 37 моих подписчиков дошли до получения работы.
Добро пожаловать всем желающим.
Экстренный набор
Когда HR-у не отвечают живые разработчики и он пытается найти их на том свете:
Разработчик с нуля спустя год и сложности дальнейшего развития
Прошел почти год, как я тут создавал пост с вопросом, как стать разработчиком. Год этот был тернист, так как я никогда ранее не занимался программированием и работой с микроконтроллерами, знал совсем немного схемотехнику и единственное что это CAD моделирование.
Как не крути, но для хорошего начала нужна толика везения и я через знакомых смог найти контору, где требовалось делать примитивные вещи, уровня помигать светодиодом, но в основном монтаж, при том навесной. Это мне позволило зарабатывать на хлеб и обучаться. По этому в первую очередь я закупился моим кумиром и кормильцем, китайской паялкой на T12, которая верой и правдой служит мне и сейчас и не поменяю я ее даже на индукционку. Купил фен, ЛБП сам собрал, нормальный мультиметр, кучу ручного инструмента для работы с проводами, в основном мгтф:
Понимаю, что лучший способ, это пойти работать в фирму, где занимаются подобными разработками, но это не путь самурая. Недавно даже приглашали в Московскую фирму, но блин, они тоже используют esp32, а он мне уже не интересен. Я бы даже заплатил кому-нибудь, что бы меня ввели в курс, что где сейчас используют, что мне надо изучить, куда копать и ответили на пару сотен моих вопросов, но что то я ни нашел таких вариантов.
Кстати, я тут пару лет назад делал пост как прожить на МРОТ, сейчас то время вспоминаю с ужасом и непониманием, как я так жил. Даже моих примитивных знаний хватает, что бы зарабатывать в несколько раз больше. И спасибо короне, из-за которой меня сократили и я решил попробовать себя в самозанятых, а то так бы и продолжал работать, думая что это нормально.
Currenttimemillis java что это
That will print a human readable time in your local timezone.
To understand exactly what System.currentTimeMills() returns we must first understand: what UTC is, what UNIX timestamps are and how they form a universal time keeping standard.
| A human readable moment in time | 2015-03-07 16:00 UTC | |
| The same moment as a UNIX timestamp in milliseconds | 1425744000000 | get it with System.currentTimeMillis() in Java get it with new Date().getTime() in Javascript get it with round(microtime(true) * 1000) in PHP |
| Note that System.currentTimeMillis() is based on the time of the system / machine it’s running on. In conclusion, the UNIX timestamp is just a system / format for representing a moment in time.
The ‘snapshot’ above represents the same moment from 4 different perspectives: John’s timezone, Juliette’s timezone, UTC (Coordinated Universal Time) and milliseconds from the Unix epoch. Java’s Calendar (and deprecated Date ) itself stores time as milliseconds since the Unix Epoch. This is great for many reasons. It happens not only in Java but in other programming languages as well. In my experience i found the perfect time-keeping architecture emerges naturally from this: the Unix Epoch is January 1st, 1970, midnight, UTC. Therefore if you choose to store time as milliseconds since the Unix Epoch you have a lot of benefits:
What might happen above is that the sorting for such a small array could be so fast that the duration shows up as zero. For this you can use the trick of repeating the method call multiple times so that you get more relevant durations & comparisons: The easiest way to manually deduce when the method started would be to convert 2015-03-15 10:13:32:564 into milliseconds, subtract 3367, then convert back to a time. The starting point of the activity is relevant because other activities that ran in parallel can be investigated. It’s important to note though that a line such as the one above is normally indicative of poor logging because if the starting point is relevant it can be calculated programmatically (and printed) at the moment of logging. System.currentTimeMillis() offers precision to the millisecond but its accuracy still depends on the underlying machine. This is why, in some cases, it might happen that two subsequent calls can return the same number even if they are in fact more than 1ms apart. The same is true about nanoTime() : precision is down to the nanosecond but accuracy doesn’t follow, it still depends on the machine. UTC stands for Coordinated Universal Time. GMT stands for Greenwich Mean Time. UTC is a universal time keeping standard by itself and a GMT successor. A time expressed in UTC is essentially the time on the whole planet. A time expressed in GMT is the time in the timezone of the Greenwich meridian. In current computer science problems (and probably most scientific ones) UTC and GMT expressed in absolute value happen to have identical values so they have been used interchangeably. A detailed analysis reveals that literature and history here are a bit ambiguous. UTC essentially appeared in 1960, GMT being the ‘main thing’ until then. Unlike GMT which is based on solar time and originally calculated a second as a fraction of the time it takes for the Earth to make a full rotation around its axis, UTC calculates a second as “the duration of 9192631770 periods of the radiation corresponding to the transition between the two hyperfine levels of the ground state of the cesium 133 atom”. UTC’s second is far more precise than GMT’s original second. In 1972 leap seconds were introduced to synchronize UTC time with solar time. These 2 turning points (different definition of a second and the introduction of leap seconds) ‘forced’ GMT to be the same as UTC based on what seemed a gradual, tacit convention. If you were to calculate true GMT today i would see it based on its original definition of 1 second = 1/86400 days and this would for sure return a different absolute value than what UTC gives us. From this point of view the name “GMT” seems deprecated, but kept around for backward compatibility, traditional timezone based representation of time and sometimes legal reasons.  Привет, друзья! Сегодня мы с вами поговорим о замечательной  Привет, дорогие дети! Сегодня я хочу рассказать вам  Дорогие дети, сегодня мы поговорим о загадочной поговорке «  Привет, дорогие дети! Сегодня мы поговорим о забавной | ||
