Потоки в Java: что такое класс Thread и как работать с многопоточностью / Skillbox Media

Содержание:

• Что такое поток в Java
• Как работают потоки в Java
• Как создать свой поток в Java
• Практика: изучаем потоки на котиках
• Состояния потока и время его жизни
• Что в итоге

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

Одноядерную систему можно оптимизировать для одновременной работы с несколькими наборами инструкций, что достигается за счёт быстрого и незаметного переключения между ними для пользователя. В этом процессе каждая подзадача управляется своим «виртуальным» ядром, или потоком, известным как thread, что и составляет суть многопоточности. Давайте подробнее рассмотрим, что такое многопоточность и как её правильно настроить.

Что такое поток в Java

Представьте себе работника лаборатории, который получил список задач. Он может выполнять каждую задачу последовательно, строго придерживаясь порядка: закончив первую, он переходит ко второй и так далее, пока не завершит все пункты. Однако существует возможность решать несколько задач одновременно. Например, он может загрузить компоненты в миксер, а пока идет процесс перемешивания, заниматься подготовкой навесок для следующей загрузки или писать отчет о результатах предыдущей работы. Такой подход может значительно ускорить выполнение задач и повысить общую эффективность работы.

В программировании существует возможность разбить крупные задачи на более мелкие подзадачи и распределить их между потоками. Потоки представляют собой абстрактные сущности, которые последовательно выполняют инструкции программы. Они функционируют в рамках процесса, который, в свою очередь, можно определить как любую запущенную программу. Разделение задач на потоки позволяет оптимизировать выполнение программ, улучшая их производительность и эффективность.

Каждый процесс включает как минимум один поток, который называется главным. Этот поток запускается в первую очередь, в то время как остальные потоки выполняются параллельно. Например, при запуске Java-программы процесс представляет собой её среду выполнения, известную как Java Runtime Environment (JRE). Главный поток отвечает за выполнение основной логики программы, в то время как параллельные потоки могут обрабатывать дополнительные задачи, что позволяет улучшить производительность и отзывчивость приложения.

Программы на Java, как правило, функционируют в синхронном режиме, где строки кода выполняются последовательно в основном потоке. Однако Java предоставляет возможность создавать и управлять несколькими потоками (тредами), что позволяет значительно повысить производительность приложений. Например, один поток может ожидать завершения работы другого, в то время как параллельно выполняет вычисления или другие задачи. Это позволяет оптимизировать использование ресурсов и ускорить выполнение программ, особенно в сценариях, требующих интенсивных вычислений или долгих операций ввода-вывода. Использование многопоточности в Java открывает новые горизонты для разработчиков, позволяя создавать более отзывчивые и эффективные приложения.

Помимо виртуальных потоков, существуют аппаратные потоки, упомянутые в начале статьи. Аппаратные потоки представляют собой реальные среды выполнения для программных потоков вашего кода. Когда код на Java оптимизирован для работы с несколькими потоками, операционная система использует соответствующее количество реальных потоков процессора. Это позволяет повысить производительность и эффективность выполнения задач, обеспечивая более быструю обработку данных и улучшая отзывчивость приложений.

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

Как работают потоки в Java

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

Команды в Java выполняются последовательно, что означает, что сначала на экране появится слово «Hello», затем пробел, и в завершение — «World». Это стандартное поведение программирования, однако его можно изменить, используя класс Thread и интерфейс Runnable из стандартной библиотеки java.lang. Применение многопоточности позволяет выполнять задачи параллельно и управлять их выполнением более эффективно, что открывает новые возможности для оптимизации работы приложений. Использование этих инструментов в Java помогает разработчикам создавать более отзывчивые и производительные программы, эффективно распределяя ресурсы и время выполнения задач.

Изучим, что покажет программа при использовании метода Thread.currentThread(), который возвращает ссылку на текущую нить выполнения. Этот метод позволяет получить информацию о текущем потоке, что может быть полезно для отладки и анализа работы многопоточных приложений. Использование Thread.currentThread() дает возможность получить такие данные, как имя потока, его приоритет и состояние. Это помогает разработчикам лучше понимать, как выполняется код в многопоточной среде, а также оптимизировать производительность приложения.

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

Имя можно получить с помощью метода getName(). Этот метод предоставляет доступ к имени объекта и может быть использован в различных контекстах. Использование getName() позволяет легко извлекать информацию о названии, что важно для дальнейшей обработки данных. Метод getName() является простым и эффективным инструментом для работы с объектами в коде.

Как создать свой поток в Java

Класс Thread представляет собой поток на уровне кода, позволяя создавать множество потоков в вашем приложении. Однако, одновременно может выполняться лишь то количество потоков, которое поддерживает ваша система. Это делает использование потоков эффективным инструментом для оптимизации выполнения задач и улучшения производительности программы.

Интерфейс Runnable представляет собой задачу, которую выполняет поток, а именно код, который необходимо исполнять. Он включает в себя ключевой метод run(), который служит точкой входа и содержит основную логику работы потока. Использование интерфейса Runnable позволяет эффективно управлять потоками в Java, обеспечивая возможность многопоточного выполнения задач.

Создание потока в Java возможно двумя основными способами. Первый способ заключается в наследовании от класса Thread, где необходимо переопределить метод run(), содержащий код, который будет выполняться в потоке. Второй способ включает реализацию интерфейса Runnable, что позволяет создать поток с помощью объекта класса Thread, передавая ему экземпляр класса, реализующего данный интерфейс. Оба метода обеспечивают параллельное выполнение задач, что способствует улучшению производительности приложений на Java.

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

• Определить класс — наследник класса Thread и переопределить метод run().
• Создать экземпляр своего класса и вызвать метод start().

Важно помнить, что при вызове метода run() экземпляра класса Thread, вместо метода start(), код будет выполняться в том же потоке, который и вызвал этот метод. В результате новый поток не будет создан, и выполнение кода произойдет в текущем контексте. Поэтому для корректного запуска нового потока обязательно используйте метод start(). Это гарантирует, что код будет выполняться в отдельном потоке, что необходимо для многопоточного программирования.

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

• Реализовать интерфейс Runnable и метод run().
• Создать экземпляр Thread и передать в конструктор свой Runnable (экземпляр класса, реализующий этот интерфейс).

Второй вариант является более гибким решением. Например, если бы класс MyThread уже наследовал другой класс, первый путь оказался бы невозможным, поскольку Java не поддерживает множественное наследование. Это подчеркивает важность выбора подходящего метода при проектировании классов в Java, чтобы обеспечить максимальную гибкость и избежать ограничений, связанных с наследованием.

Практика: изучаем потоки на котиках

Создадим простую консольную игру, в которой главными героями будут коты. Обещаем, что в ходе разработки программы ни один кот не пострадает. Вы сможете наблюдать, как «нити» взаимодействуют и соревнуются друг с другом. Эта игра не только развлечет, но и покажет основы многопоточности в программировании.

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

• synchronized перед методом означает, что он синхронизирован. Поток, вызвавший синхронизированный метод, запрещает другим нитям к нему обращаться, пока сам не выйдет из метода.
• volatile нужен, когда одну переменную используют разные потоки, во избежание некорректных результатов.
• Класс CopyOnWriteArrayList — это тот же ArrayList, только потокобезопасный, то есть оптимизированный под использование нескольких потоков. Он находится в библиотеке java.util.concurrent.

Программа включает в себя два класса: CatFightsConsole и Cat. В начале запуска создаётся N боевых котов, которые затем вступают в схватки друг с другом. Каждый кот старается первым вызвать метод Cat.attack(), чтобы атаковать случайного соперника и забрать у него жизнь. Как только жизнь кота достигает нуля, его поток завершает выполнение. Бои продолжаются до тех пор, пока не останется последний выживший кот.

Класс CatFightsConsole включает метод main(String[] args), который отвечает за начальную настройку программы. В этом методе создаются и настраиваются необходимые объекты, а также запускаются потоки. Главный поток затем использует метод join(), который приостанавливает его выполнение до тех пор, пока не завершится поток, на котором этот метод был вызван. После того как все «кототреды» закончат свою работу, в консоль будет выведено сообщение о коте-победителе. Это позволяет пользователю узнать результат боя между котами.

Класс Cat включает в себя такие атрибуты, как имя (String name) и количество жизней (int life). Он также содержит личный поток и статический список cats, который хранит ссылки на все экземпляры класса Cat. Реализуя интерфейс Runnable, класс Cat обеспечивает основной цикл работы потока через метод run().

При запуске потока, когда объектов Cat больше одного и у них есть жизни, вызывается синхронизированный статический метод Cat.attack(). Этот метод уменьшает переменную life у второго переданного объекта, используя метод decrementLife(). Если после уменьшения значение life становится равным нулю, у этого объекта вызывается метод getThread(), который затем вызывает interrupt() — функцию, прерывающую выполнение потока.

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

Изучите, как изменятся потоки в случае, если «котам» предоставить 1 или 100 000 жизней. Убедитесь, что в процессе вычислений здоровья не возникают ошибки и все потоки завершаются успешно.

Вы можете улучшить код, экспериментируя с потоками. Например, добавьте новых котов, измените их характеристики урона или создайте новый класс. При этом стоит задуматься над механизмом взаимодействия между ними. Это не только повысит интерес к проекту, но и даст возможность лучше понять структуру кода и логику работы программы.

Состояния потока и время его жизни

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

Метод getState() позволяет получить текущее состояние потока. Он возвращает одно из значений перечисления State, которое включает шесть констант. Эти константы отображают различные состояния потока и позволяют разработчикам легко отслеживать его статус в процессе выполнения.

• ‌NEW — новый, только что созданный поток. Это состояние присваивается, когда выделяется память для объекта.

• ‌RUNNABLE — вызывая метод start(), поток становится готовым к выполнению, а затем выполняемым.
• ‌BLOCKED / WAITING / TIME_WAITING — данные состояния означают, что поток находится в ожидании своего выполнения.
• ‌TERMINATED — после завершения работы поток уничтожается.

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

При запуске нового потока старый поток продолжает свою работу. Вызвав метод join(), главный поток временно переходит в состояние WAITING и затем возвращается в состояние RUNNABLE после завершения работы присоединяемого потока. По окончании выполнения программы все потоки переходят в состояние TERMINATED. Это поведение потоков важно учитывать при проектировании многопоточных приложений, чтобы обеспечить правильное завершение и управление ресурсами.

Существует метод isAlive(), который используется для определения состояния потока. Этот метод возвращает логическое значение: true, если поток активен, и false, если он завершен. Использование isAlive() помогает эффективно управлять потоками и отслеживать их жизненный цикл.

Что в итоге

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

• ‌Потоки — это виртуальные сущности, которые последовательно выполняют код. Они протекают в процессах, где процесс — это программа, которая выполняется.
• ‌Поток можно создать двумя способами: унаследовать класс Thread или реализовать интерфейс Runnable.
• ‌Вся логика нового треда выполняется в методе run(), а запускается он методом start().
• ‌Поток имеет свой жизненный цикл и шесть состояний, описанных в перечислении ‌State.
• ‌State — это свойство класса Thread, которое содержит состояния потока, а получить его можно с помощью метода getState().
• Метод join() переводит в ожидание текущий поток, а interrupt() прерывает его работу.

Многопоточность является ключевым аспектом программирования, который существенно влияет на производительность современных систем. Использование нескольких потоков позволяет эффективно выполнять множество задач одновременно, что особенно важно для приложений, требующих высокой производительности. Понимание принципов работы многопоточности помогает разработчикам оптимизировать свои программы, улучшать их отзывчивость и использовать ресурсы компьютера более рационально. Освоение данной темы открывает новые возможности для создания эффективных и масштабируемых решений в программировании.

Изучите также:

• Готовимся к собеседованию: что нужно знать о коллекциях в Java
• Тест. Какой язык создадите вы — Java или Python?
• Начинаем программировать на Python