его метод run пустой.
Поэтому нужно создать подкласс класса Thread и предоставить собственную реализацию метода run.
Таким образом, первая ключевая операция — это создание потоков.
Но ключевой момент здесь — вам нужно указать вычисление, которое должно быть выполнено в потоке.
Затем после создания потока, он фактически не начинает выполнение.
Поэтому, следующее, что вам нужно сделать, это вызвать метод start.
Теперь, ваша основная программа сама по себе является потоком.
И у нас есть основной поток, который создает и запускает другой поток.
В другом потоке выполняется свой код.
Теперь основной поток после запуска другого потока может выполнить свой код.
В этом случае у нас параллельно выполняются два куска кода на двух разных ядрах.
Класс Thread содержит метод join.
Метод join может быть использован для того, чтобы приостановить выполнение текущего потока до тех пор, пока другой поток не закончит свое выполнение.
Как правило, мы используем более одного потока.
В этом случае, планировщик потоков планирует потоки, что не гарантирует порядок выполнения потоков.
В идеальном мире все потоки всех программ работают на отдельных процессорах.
Но в реальности, потоки должны разделяться между одним или несколькими процессорами.
Либо JVM, либо операционная система базовой платформы определяют, как распределять ресурс процессора среди потоков — задача, известная как планирование потоков.
Эта часть JVM или операционной системы, которая выполняет планирование потоков, является планировщиком потоков.
Java не заставляет виртуальную машину планировать потоки определенным образом, поэтому планирование потоков зависит от конкретной платформы.
Предположим, у нас есть два потока t1 и t2.
Несмотря на то, что мы запустили потоки последовательно, планировщик потоков не запускает и не завершает их в указанном порядке.
Каждый раз, когда вы запускаете этот код, вы можете получить разные результаты.
А если поток t1 должен использовать вычисления потока t2, что нам делать?
Решить эту проблему мы можем с помощью метода join ().
Этот код запустит второй поток t2, только после завершения первого потока t1, так как метод join приостанавливает выполнение главного потока до тех пор, пока не завершится поток t1.
Если поток прерывается, бросается исключение InterruptedException.
Теперь, предположим, что мы передали в метод run класса MyClass основной поток и применили к нему метод join.
Тогда первый поток будет ждать, когда завершится основной поток, а основной поток будет ждать, когда завершится первый поток.
Возникнет дедлок deadlock или взаимная блокировка потоков.
Для отладки долгоиграющих операций, например, сетевых запросов, часто используется статический метод sleep класса Thread.
Вызов этого метода ставит выполнение текущего потока на паузу, при этом нужно указать количество миллисекунд паузы.
Здесь также нужно обрабатывать исключение InterruptedException.
Это исключение, которое метод бросает, когда другой поток прерывает текущий поток, при работающем методе.
Теперь, вы можете столкнуться с ситуацией, когда вам нужно выполнить некоторые длительные задачи в отдельных потоках.
И возможно, вам нужно будет завершить работу какой-либо задачи еще до того, как задача будет полностью выполнена, с помощью остановки соответствующего потока.
Например, при закрытии приложения, которое может использовать несколько потоков, и они могут быть не завершены в момент закрытия приложения.
Как запросить задачу, выполняемую в отдельном потоке, закончиться раньше?
Как заставить задачу реагировать на такой запрос?
В этом примере создается задача, которая печатает числа от 0 до 9 в консоли.
После печати числа, задача должна подождать 1 секунду перед печатью следующего числа.
Задача выполняется в отдельном потоке, отличном от основного потока приложения.
После запуска задачи основной поток должен подождать 3 секунды и затем завершить работу.
При завершении работы приложение должно запросить завершение выполняемой задачи.
Перед тем, как полностью закрыть приложение, приложение должно максимально ждать 1 сек для завершения задачи.
Задача должна ответить на запрос завершения, немедленно останавливаясь.
Общее выполнение задачи занимает не менее 9 секунд.
Поэтому задача не сможет распечатать все десять чисел от 0 до 9.
Для запроса на прерывание потока, основной поток вызывает метод прерывания interrupt.
В Java один поток не может просто остановить другой поток.
Поток может только запросить остановку другого потока.
И запрос выполняется в виде вызова метода interrupt.
Вызов метода interrupt в экземпляре Thread устанавливает флаг прерывания как true.
Если этот поток заблокирован вызовом методов wait, join или sleep, то его статус прерывания будет очищен, и он выбросит исключение InterruptedException.
Таким образом, как только taskThread прерывается основным потоком, Thread.sleep (1000) отвечает на прерывание, выбрасывая исключение.
Исключение InterruptedException обрабатывается, прерывая цикл и тем самым заканчивая задачу раньше.
Таким образом, чтобы задача немедленно реагировала на запрос прерывания, можно использовать обработку исключения InterruptedException.
После очистки статуса прерывания, подтвердить этот статус можно самопрерыванием с помощью вызова Thread.currentThread(). interrupt ().
И без использования обработки InterruptedException, прервать цикл задачи можно, проверяя статус прерывания с помощью вызова Thread.isInterrupted ().
Теперь, когда мы рассмотрели потоки, давайте разберем ключевую концепцию в многопоточном программировании, которая идет рука об руку с потоками, и это блокировки.
Потоки взаимодействуют между собой, главным образом, путем совместного доступа к полям объектов.
Это взаимодействие делает возможными два вида ошибок: интерференция потоков и ошибки согласованности памяти.
Предположим, что у нас есть очень простой метод объекта, который принимает число и увеличивает его на единицу.
Другой метод этого объекта уменьшает это число на единицу.
Предположим, есть два потока T1 и T2, и один поток хочет увеличить число, а другой поток хочет уменьшить число.
Эти два потока могут быть запланированы на двух разных ядрах, и они могут читать и записывать поле объекта в одно и то же время, и результат будет непредсказуемым.
При одновременной записи возникнет интерференция потоков.
А при одновременной записи и чтении возникнет ошибка согласованности памяти.
Как нам избежать ситуации, когда два потока хотят получить доступ к одному и тому же объекту одновременно?
Для этого используется блокировка.
Java обеспечивает блокировки для защиты определенных частей кода, которые будут выполняться несколькими потоками одновременно.
Самый простой способ блокировки определенного метода — это определить метод с ключевым словом synchronized.
Ключевое слово synchronized в Java обеспечивает:
Что только один поток может одновременно выполнять блок кода
Что каждый
