Threads in Java
Before knowing about the threads in Java first we need to know about Multitasking.
The basic idea of multitasking is doing more than one thing at the same time. But can computers can do more than one task at a time? Actually, no, using techniques like timesharing in the OS kernel can switch between the tasks rapidly without even noticing. for this modern processors use “Cores” which is a processing unit inside the Central Processing Unit. However, computers with multiple processors can have a level of multitasking.
In computers, this multitasking can have two approaches is Process-Based and the other one is Thread Based.
What process-based multitasking is, it actually provides the ability to run multiple processes completely independent from one another, for example, a web browser running and at the same time a music player application playing music.
Thread-based multitasking actually consists of multiple threads, a thread is a small part of execution owned by a process, so one process can have multiple threads. These multiple threads are executing simultaneously. The “Cores” in the processors are responsible for making the best use of threads.
Not let’s find about threads in Java a detailed view.
What are Threads in Java?
As we discussed threads are execution paths. This can be a method or business logic involve inside the program. To run the Java, thread Thread Scheduler needs to allocate a portion of resources from the CPU, and the Java program is not the only program running on a computer so OS threads will get the priority too due to that reason predicting the execution order is impossible (if running as usually without any criteria).
Due to this uncertainty of predicting the order of execution programmers cannot assign a set of processes into individual threads and wait for the result because if there are any dependencies among them then the expected outcome will be not there.
Java's main method is also a thread, it is non-daemon to be exact. the start of the JVM begins with the start of the non-daemon thread and the JVM will exit at the end of the execution of the last non-daemon thread.
Thread Life Cycle
Like the processes running on OS, the thread also has its own states, based on the availability of time and priority these Threads have to change their states continuously.
NEW — Moment a new Thread created, but not yet started.
RUNNABLE — The thread is in the executing mode.
BLOCKED —The thread is blocked and waiting for the monitor lock to be released.
WAITING — The thread is waiting as long as it takes another thread’s signal.
TIMED_WAITING — The thread is waiting for a specific period of time
TERMINATED — The thread has exited.
These thread state transitions are not immediate. Thread Scheduler needs to allocate the CPU time based on availability.
Creating Threads
There are two main ways to create Threads in Java one is that to “implements” from the Runnable interface
Another way is to “extends” from the Thread class.
The way it looks both are the same, So what is the difference and what is the use of having two different ways of doing the same thing? Java is based on OOP principles, the classes we create should have a proper order of hierarchy.
As an example, if we are creating a Vehicle,
A flow will be similar to like this, But in case If we want to add a Thread class, it will break the connections between the relative class, and also unlike languages like C+, Java does not provide multiple inheritances, in that case, there is no way of using more than one parent classes, At that time there we can use the interface.
Let’s see an example of creating threads in two different ways.
The above example of what it does is that it extends from the Thread class and overrides the run() method to add the functionality to run. Is it necessary to override? No! But the idea of creating a thread is to run some functionality, the responsibility of the run method is to hold that functionality, in case if it does not overrides the run() method it does nothing.
Now Let’s see how to run this,
Simply we create an object from the class, and call the method “start()”. Ok, why not run? We discussed that the responsibility of run is to hold the functionality to run(). But threading is a complex process the way it handles by communicating with the JVM, OS, creating a thread, adding them to a thread pool, all those should be handled. All those processes will be handled using the “start()” method.
Though we can call the “run()” method directly the program it will run without any error but it will not create a separate thread, It will run on the main thread.
Now Let’s see using the other way by using Runnable Interface.
Now things got started to change, unlike the Thread class when using the interface it is now enforcing the developer to override the “run()” method, otherwise it will lead to a compiler error.
When looking at the implementation the Runnable class is actually is Functional Interface (which contains only one abstract method). So now there is no way of inheriting the start() method, attributes, or other functionalities provided by the Thread class. Now how we run this. ��
Now again we have to use the Thread class as a wrapper class for the Instance (Object) for the class created using the Runnable interface. Here’s how we do it.
By wrapping using a thread Object, Now it can use all the methods necessary for Thread operations.
Java provides us the ability to override these methods without any restrictions, But this will affect the way how a thread should work. when a custom implementation is going on, in the functionality of a Thread class it is always better to reference its parent class implementation too, (ex — “super.start()”)
Priorities in Threads
The execution order of Threads are cannot be predicted as expected, But in Java Threads, it provided us to have a mechanism to assign priorities for the Threads one over another.
The thread priorities are value-based approach unlike the data structures it is not index-based. Java has defined ranges to define thread priorities, those are,
But the values are not limited to these ranges they can be valued from 1 to 10 and less than or greater value other than this range cause “IllegalArgumentException”.
Priorities of the threads are inheritable, they are using the value of the main thread’s priority unless it’s not explicitly set value. Here’s an example,
Thread-Join
There may be scenarios where two or more different threads have to wait to do the rest of the process till other threads are finished. Java provided the method “join()” for these types of scenarios. The “Join” method has different implementations.
- join() — This method waits until a specific method completes it works
- join(long milliseconds) — This method waits until a certain period of
- join(long milliseconds, int nanoseconds) — This method also waits for a certain period of time but a little bit of precise time
In the above example, it creates two Java threads one is counting from 1 to 10 and the other is 11 to 20. “threadTwo” has to wait until it “threadOne ” completes, so the joining should be “threadOne.join()”.
The output will result like this,
Operations in Threads
Threads have varieties of other functionalities to work without causing collisions and with safety and allocating time. this is necessary if to keep the application flow smoothly. Java has few valuable operations that are.
Yield
“yield()” is a native static method in Thread class, it should deal with the native libraries to do its job.
What “Thread.yield()” does is at the moment the method is called it gives its timeslot for another thread to run.
Sleep and Interrupt
The “sleep()” method provides the ability to a thread wait for a certain time putting the thread into a TIMED_WAITING state, It has two ways of defining,
And interrupt() method, wait till the method goes into sleep() and trigger the method to interrupt the sleep, but interrupting a non-sleeping method won’t throw an exception it just follows the usual path.
Name already in use
java_for_beginners_book / c11.md
- Go to file T
- Go to line L
- Copy path
- Copy permalink
1 contributor
Users who have contributed to this file
- Open with Desktop
- View raw
- Copy raw contents Copy raw contents
Copy raw contents
Copy raw contents
Основные навыки и понятия
- Общее представление о многопоточной обработке
- Класс Thread и интерфейс Runnable
- Создание потока
- Создание нескольких потоков
- Определение момента завершения потока
- Использование приоритетов потоков
- Представление о синхронизации потоков
- Применение синхронизированных блоков
- Взаимодействие потоков
- Приостановка, возобновление и остановка потоков
Среди многих замечательных свойств языка Java особое место принадлежит поддержке многопоточного программирования. Многопоточная программа состоит из двух или более частей, выполняемых параллельно. Каждая часть такой программы называется потоком и определяет отдельный путь выполнения команд. Таким образом, многопоточная обработка является особой формой многозадачности.
Общее представление о многопоточной обработке
Различают две разновидности многозадачности: на основе процессов и на основе потоков. В связи с этим важно понимать отличия между ними. Процесс фактически представляет собой исполняемую программу. Поэтому многозадачность на основе процессов — это средство, благодаря которому на компьютере могут параллельно выполняться две программы или более. Так, многозадачность на основе процессов позволяет одновременно выполнять программы текстового редактора, электронных таблиц и просмотра содержимого в Интернете. При организации многозадачности на основе процессов программа является наименьшей единицей кода, выполнение которой может координировать планировщик задач.
Поток представляет собой координируемую единицу исполняемого кода. Своим происхождением этот термин обязан понятию “поток исполнения”. При организации многозадачности на основе потоков у каждого процесса должен быть по крайней мере один поток, хотя их может быть и больше. Это означает, что в одной программе одновременно можно решать две и более задачи. Например, текст может форматироваться в редакторе текста одновременно с его выводом на печать, при условии, что оба эти действия выполняются в двух отдельных потоках. Несмотря на то что программы на Java выполняются в среде, поддерживающей многозадачность на основе процессов, в самих программах управлять процессами нельзя. В них можно управлять только потоками.
Главное преимущество многопоточной обработки заключается в том, что она позволяет писать программы, которые работают очень эффективно благодаря возможности выгодно использовать время простоя, неизбежно возникающее в ходе выполнения большинства программ. Как известно, большинство устройств ввода-вывода, будь то устройства, подключенные к сетевым портам, накопители на дисках или клавиатура, работают намного медленнее, чем центральный процессор (ЦП). Поэтому большую часть своего времени программе приходится ожидать отправки данных на устройство ввода-вывода или приема информации из него. А благодаря многопоточной обработке программа может решать какую-нибудь другую задачу во время вынужденного простоя. Например, в то время как одна часть программы отправляет файл через соединение с Интернетом, другая ее часть может выполнять чтение текстовой информации, вводимой с клавиатуры, а третья — осуществлять буферизацию очередного блока отправляемых данных.
Как известно, за последние несколько лет широкое распространение нашли многопроцессорные или многоядерные вычислительные системы, хотя по-прежнему повсеместно используются и однопроцессорные системы. В этой связи следует иметь в виду, что языковые средства организации многопоточной обработки в Java пригодны для обеих разновидностей вычислительных систем. В одноядерной системе параллельно выполняющиеся потоки разделяют ресурсы одного ЦП, получая по очереди квант времени ЦП. Поэтому в одноядерной системе два или более потока на самом деле не выполняются параллельно, а лишь используют время простоя ЦП. С другой стороны, в многопроцессорных или многоядерных системах два потока или более могут выполняться параллельно. Это, как правило, позволяет повысить производительность программ и скорость выполнения отдельных операций.
Поток может находиться в одном из нескольких состояний. В целом поток может быть выполняющимся; готовым к выполнению, как только он получит время и ресурсы ЦП; приостановленным, т.е. временно не выполняющимся; возобновленным в дальнейшем; заблокированным в ожидании ресурсов для своего выполнения; а также завершенным, когда его выполнение окончено и не может быть возобновлено.
В связи с организацией многозадачности на основе потоков возникает потребность в особого рода режиме, который называется синхронизацией и позволяет координировать выполнение потоков вполне определенным образом. Для такой синхронизации в Java предусмотрена отдельная подсистема, основные средства которой рассматриваются в этой главе.
Если вы пишете программы для таких операционных систем, как Windows, то принципы многопоточного программирования вам должны быть уже знакомы. Но то обстоятельство, что в Java имеются языковые средства для поддержки потоков, упрощает организацию многопоточной обработки, поскольку избавляет от необходимости реализовывать ее во всех деталях.
Класс Thread и интерфейс Runnable
В основу системы многопоточной обработки в Java положены класс Thread и интерфейс Runnable, входящие в пакет java. lang. Класс Thread инкапсулирует поток исполнения. Для того чтобы образовать новый поток, нужно создать класс, являющийся подклассом Thread или реализующий интерфейс Runnable.
В классе Thread определен ряд методов, позволяющих управлять потоками. Некоторые из этих наиболее употребительных методов описаны ниже. По мере их представления в последующих примерах программ вы ознакомитесь с ними поближе.
| Метод | Описание |
|---|---|
| final String getName() | Получает имя потока |
| final int getPriority() | Получает приоритет потока |
| final boolean isAliveO | Определяет, выполняется ли поток |
| final void join() | Ожидает завершения потока |
| void run() | Определяет точку входа в поток |
| static void sleep(long миллисекунд) | Приостанавливает исполнение потока на указанное число миллисекунд |
| void start() | Запускает поток, вызывая его метод run() |
В каждом процессе имеется как минимум один поток исполнения, который называется основным потоком. Он получает управление уже при запуске программы.
Следовательно, во всех рассматривавшихся до сих пор примерах программ использовался основной поток. От основного потока могут быть порождены другие, подчиненные потоки.
Для того чтобы создать поток, нужно построить объект типа Thread. Класс Thread инкапсулирует объект, который может стать исполняемым. Как пояснялось ранее, пригодные для исполнения объекты можно создавать в Java двумя способами:
- реализуя интерфейс Runnable;
- создавая подкласс класса Thread.
В большинстве примеров, представленных в этой главе, будет применяться первый способ. Хотя в примере для опробования 11.1 будет продемонстрировано, каким образом поток реализуется путем расширения класса Thread. Но независимо от выбранного способа создание экземпляра потока, организация доступа к нему и управление потоком осуществляется средствами класса Thread. Единственное отличие обоих способов состоит в том, как создается класс, активизирующий поток.
Интерфейс Runnable дает абстрактное описание единицы исполняемого кода. Для формирования потока подходит любой объект, реализующий этот интерфейс. В интерфейсе Runnable объявлен только один метод, run():
В теле метода run() определяется код, соответствующий новому потоку. Из этого метода можно вызывать другие методы, использовать в нем различные классы и объявлять переменные таким же образом, как это делается в основном потоке. Единственное отличие состоит в том, что метод run() создает точку входа в поток, исполняемый в программе параллельно с основным. Этот поток исполняется до тех пор, пока не произойдет возврат из метода run().
После создания класса, реализующего интерфейс Runnable, следует создать экземпляр объекта типа Thread на основе объекта данного класса. В классе Thread определен ряд конструкторов. В дальнейшем будет использоваться следующий конструктор:
В качестве параметра threadOb этому конструктору передается экземпляр класса, реализующего интерфейс Runnable. Благодаря этому определяется место для исполнения потока.
Созданный поток не начнет исполнение до тех пор, пока не будет вызван метод start(), объявленный в классе Thread. По существу, единственным назначением метода start() является вызов метода run(). А объявляется метод start() следующим образом:
Ниже приведен пример программы, в которой создается и запускается на исполнение новый поток.
Рассмотрим исходный код приведенной выше программы более подробно. Как видите, класс MyThread реализует интерфейс Runnable. Это означает, что объект типа MyThread подходит для использования в качестве потока, а следовательно, его можно передать конструктору класса Thread.
В теле метода run() присутствует цикл, в котором производится отсчет от 0 до 9. Обратите внимание на вызов метода sleep(). Этот метод приостанавливает поток, из которого он был вызван на указанное число миллисекунд. Ниже приведена общая форма объявления данного метода.
Единственный параметр метода sleep() задает время задержки, определяемое числом миллисекунд. Как следует из объявления этого метода, в нем может быть сгенерировано исключение InterruptedException. Следовательно, его нужно вызывать в блоке try. Имеется и другой вариант метода sleep(), позволяющий точнее указывать время задержки в миллисекундах и дополнительно в наносекундах. Когда метод sleep() вызывается в методе run(), исполнение потока приостанавливается на 400 миллисекунд на каждом шаге цикла. Благодаря этому поток исполняется достаточно медленно, чтобы можно проследить за ним.
В методе main() создается новый объект типа Thread. Для этой цели служит приведенная ниже последовательность операторов.
Как видите, сначала создается объект типа MyThread, а затем он используется для построения объекта типа Thread. Его можно передать конструктору класса Thread в качестве параметра, поскольку класс MyThread реализует интерфейс Runnable. И наконец, начинается исполнение нового потока, для чего вызывается метод start(), что приводит к вызову метода run() из порожденного потока. После вызова метода start() управление возвращается к методу main(), где начинается выполнение цикла for. Этот цикл повторяется 50 раз, приостанавливая на 100 миллисекунд исполнение потока на каждом своем шаге. Оба потока продолжают исполняться, разделяя ресурсы
ЦП в однопроцессорной системе до тех пор, пока циклы в них не завершатся. Ниже приведен результат выполнения данной программы. Вследствие отличий в вычислительных средах у вас может получиться несколько иной результат.
В рассматриваемом здесь первом примере организации многопоточной обработки любопытно также отметить следующее обстоятельство: для демонстрации того факта, что основной и порожденный потоки исполняются одновременно, необходимо задержать завершение метода main() до тех пор, пока не окончится порожденный поток mt. В данном примере это достигается благодаря отличиям во временных характеристиках обоих потоков. Вызовы метода sleep() из цикла for в методе main() приводят в итоге к задержке на 5 секунд (50 шагов цикла х 100 миллисекунд), тогда как общая задержка с помощью того же самого метода в аналогичном цикле в методе run() составляет лишь 4 секунды (10 шагов цикла х 400 миллисекунд). Поэтому метод run() завершится приблизительно на 1 секунду раньше, чем метод main(). В итоге основной и порожденный потоки будут выполняться параллельно до тех пор, пока не завершится порожденный поток mt. А приблизительно через одну секунду завершится и основной поток в методе main().
Отличий во временнь/х характеристиках обоих потоков в данном и ряде последующих простых примеров оказывается достаточно для того, чтобы основной поток в методе main() завершился последним, но на практике этого, как правило, оказывается недостаточно. В Java предоставляются намного более совершенные способы, позволяющие организовать ожидание завершения потока. Далее в этой главе будет продемонстрирован более совершенный способ организации ожидания одним потоком завершения другого.
И последнее замечание: многопоточная программа обычно разрабатывается с таким расчетом, чтобы последним завершал свою работу основной поток. Как правило, выполнение программы продолжается до тех пор, пока все потоки не завершат работу. Поэтому завершение основного потока является не требованием, а рекомендуемой для наследования нормой, особенно для тех, кто лишь начинает осваивать многопоточное программирование.
Несложные усовершенствования многопоточной программы
Рассмотренная выше многопоточная программа вполне работоспособна, тем не менее ей не помешает небольшая доработка, повышающая ее эффективность. Во- первых, можно сделать так, чтобы поток начинал исполняться сразу после создания. Эта цель достигается созданием экземпляра объекта типа Thread в конструкторе класса MyThread. И во-вторых, нет никакой нужды хранить в объекте типа MyThread имя потока, но присвоить имя потоку при его создании. Эту задачу позволяет решить следующий вариант конструктора Thread:
где имя обозначает конкретное наименование потока.
Получить имя потока можно, используя метод getName(), определенный в классе Thread. Ниже приведено объявление этого метода.
В приведенной ниже программе имя присваивается потоку после его создания с помощью метода setName(). И хотя в этом нет особой необходимости, такое решение выбрано лишь для того, чтобы продемонстрировать возможности класса Thread. Объявление метода setName() имеет следующий вид:
где имя_потока обозначает имя, которое присваивается потоку.
Ниже приведена видоизмененная версия предыдущей программы.
Эта версия программы дает такой же результат, как и предыдущая. Обратите внимание на то, что ссылка на поток хранится в переменной thrd экземпляра класса MyThread.
Пример для опробования 11.1. Расширение класса Thread
Реализация интерфейса Runnable — это лишь один из способов получения экземпляров потоковых объектов. Другой способ состоит в создании подкласса, производного от класса Thread. В этом проекте будет продемонстрировано, каким образом расширение класса Thread позволяет реализовать такие же функциональные возможности, как и у рассмотренной выше программы UseThreadsImproved.
В подклассе, производном от класса Thread, нужно переопределить метод run(), который является точкой входа в новый поток. Для того чтобы начать исполнение нового потока, следует вызвать метод start(). Можно также переопределить и другие методы из класса Thread, но делать это не обязательно.
- Создайте файл ExtendThread.java. Скопируйте в этот файл исходный код второго рассмотренного ранее примера программы (файл UseThreadsImproved. java).
- Измените объявление класса MyThread. Теперь он должен быть подклассом, производным от класса Thread, как показано ниже.
Создание нескольких потоков
В предыдущем примере был создан только один порожденный поток. Но в программе можно породить столько потоков, сколько требуется. Например, в приведенной ниже программе формируются три порожденных потока.
Ниже приведен результат выполнения данной программы.
Как видите, после запуска на исполнение все три потока совместно используют ресурсы ЦП. Следует иметь в виду, что потоки в данном примере запускаются на исполнение в том порядке, в каком они были созданы. Но так происходит не всегда. Исполняющая система Java сама планирует исполнение потоков. Вследствие отличий в вычислительных средах у вас может получиться несколько иной результат.
Определение момента завершения потока
Нередко требуется знать, когда завершится поток. Так, в приведенных выше примерах ради большей наглядности нужно было поддерживать основной поток действующим до тех пор, пока не завершатся остальные потоки. Для этой цели основной поток переводился в состояние ожидания на более продолжительное время, чем порожденные им потоки. Но такое решение вряд ли можно считать удовлетворительным или общеупотребительным!
Правда, в классе Thread предусмотрены два средства, позволяющие определить, завершился ли поток. Первым из них является метод is Alive(), объявление которого приведено ниже.
Этот метод возвращает логическое значение true, если поток, для которого он вызывается, все еще исполняется. В противном случае он возвращает логическое значение false. Для того чтобы опробовать метод isAlive() на практике, замените в предыдущей программе класс MoreThreads новой версией, исходный код которой приведен ниже.
Эта версия дает такой же результат, как и предыдущая. Единственное отличие состоит в том, что в данном случае ожидание завершения порожденного потока организовано с помощью метода isAlive(). Вторым средством, позволяющим определить, завершился ли поток, является метод join(), объявление которого приведено ниже.
Этот метод ожидает завершения потока, для которого он был вызван. Его имя join выбрано потому, что вызывающий поток ожидает, когда указанный поток присоединится (англ.уши) к нему. Имеется и другой вариант метода j oin(), позволяющий указать максимальное время ожидания момента, когда поток завершится.
В приведенном ниже примере программы наличие метода join() гарантирует, что основной поток завершит работу последним.
Результат выполнения данной программы приведен ниже. Вследствие отличий в вычислительных средах он может получиться у вас несколько иным.
Как видите, после того как вызываемый метод j oin() возвращает управление, исполнение потока прекращается.
У каждого потока имеется свой приоритет, который отчасти определяет, насколько часто поток получает доступ к ЦП. Вообще говоря, низкоприоритетные потоки получают доступ к ЦП реже, чем высокоприоритетные. Таким образом, в течение заданного промежутка времени низкоприоритетному потоку будет доступно меньше времени ЦП, чем высокоприоритетному. Как и следовало ожидать, время ЦП, получаемое потоком, оказывает определяющее влияние на характер его исполнения и взаимодействия с другими потоками, исполняемыми в настоящий момент в системе.
Следует иметь в виду, что, помимо приоритета, на частоту доступа потока к ЦП оказывают влияние и другие факторы. Так, если высокоприоритетный поток ожидает доступа к некоторому ресурсу, например для ввода с клавиатуры, он блокируется, а вместо него исполняется низкоприоритетный поток. Но когда высокоприоритетный поток получит доступ к ресурсам, он прервет низкоприоритетный поток и возобновит свое исполнение. На планирование работы потоков оказывает также влияние способ, посредством которого в операционной системе поддерживается многозадачность (см. врезку “Обращение к знатоку” в конце этого раздела). Следовательно, если один поток имеет более высокий приоритет, чем другой поток, это еще не означает, что первый поток будет исполняться быстрее второго. Высокий приоритет потока лишь означает, что потенциально он может получить больше времени ЦП.
При запуске порожденного потока его приоритет устанавливается равным приоритету родительского потока. Изменить приоритет можно, вызвав метод setPriority() из класса Thread. Ниже приведено объявление этого метода,
В качестве параметра уровень данному методу передается новый приоритет для потока. Значение параметра уровень должно находиться в пределах от MIN PRIORITY до MAX PRIORITY. В настоящее время этим константам соответствуют числовые значения от 1 до 10. Для того чтобы восстановить приоритет потока по умолчанию, следует указать значение 5, которому соответствует константа N0RM PRI0RITY. Константы, определяющие приоритеты потоков, определены как static final в классе Thread.
Получить текущий приоритет можно с помощью метода getPriorityO из класса Thread, объявляемого следующим образом:
Ниже приведен пример программы, демонстрирующий использование двух потоков с разными приоритетами. Потоки создаются как экземпляры класса Priority. В методе run() содержится цикл, отсчитывающий число своих шагов. Этот цикл завершает работу, когда значение счетчика достигает 10000000 или же когда статическая переменная stop принимает логическое значение true. Первоначально переменной stop присваивается логическое значение false, но первый же поток, заканчивающий отсчет, устанавливает в ней логическое значение true. В результате второй поток завершится, как только ему будет выделен квант времени. В цикле производится проверка символьной строки в переменной currentName на совпадение с именем исполняемого потока. Если они не совпадают, это означает, что произошло переключение задач. При этом отображается имя нового потока, которое присваивается переменной currentName. Это дает возможность следить за тем, насколько часто каждый поток получает время ЦП. После остановки обоих потоков выводится число шагов, выполненных в каждом цикле.
Результат выполнения данной программы выглядит следующим образом:
В данном примере большую часть времени ЦП получает высокоприоритетный поток. Очевидно, что результат выполнения программы существенно зависит от быстродействия ЦП и их количества, типа операционной системы и наличия прочих задач, выполняющихся в системе.
Если в программе используется несколько потоков, то иногда приходится координировать действия двух потоков или более. Процесс достижения такой координации называется синхронизацией. Самой распространенной причиной для синхронизации является необходимость разделять среди двух или более потоков общий ресурс, который может быть одновременно доступен только одному потоку. Например, когда в одном потоке выполняется запись информации в файл, второму потоку должно быть запрещено делать это в тот же самый момент времени. Синхронизация требуется и в том случае, если один поток ожидает событие, вызываемое другим потоком. В подобной ситуации требуются какие-то средства, позволяющие приостановить один из потоков до тех пор, пока не произойдет событие в другом потоке. После этого ожидающий поток может возобновить свое выполнение.
Главным для синхронизации в Java является понятие монитора, контролирующего доступ к объекту. Монитор реализует принцип блокировки. Если объект заблокирован одним потоком, то он оказывается недоступным для других потоков. В какой-то момент объект разблокируется, и другие потоки могут обращаться к нему.
У каждого объекта в Java имеется свой монитор. Этот механизм встроен в сам язык. Следовательно, все объекты поддаются синхронизации. Для поддержки синхронизации в Java предусмотрено ключевое слово synchronized и ряд вполне определенных методов у каждого из объектов. А поскольку средства синхронизации встроены в язык, то пользоваться ими на практике очень просто — гораздо проще, чем может показаться на первый взгляд. Для многих программ средства синхронизации объектов по сути прозрачны.
Синхронизировать код можно двумя способами. Оба способа рассматриваются ниже, и в обоих используется ключевое слово synchronized.
Применение синхронизированных методов
Для того чтобы синхронизировать метод, в его объявлении следует указать ключевое слово synchronized. Когда такой метод получает управление, вызывающий поток активизирует монитор, что приводит к блокированию объекта. Если объект блокирован, он недоступен из другого потока, а кроме того, его нельзя вызвать из других синхронизированных методов, определенных в классе данного объекта. Когда выполнение синхронизированного метода завершается, монитор разблокирует объект, что позволяет другому потоку использовать этот метод. Таким образом, для достижения синхронизации программирующему на Java не приходится прилагать каких-то особых усилий.
Ниже приведен пример программы, демонстрирующий контролируемый доступ к методу sumArray(). Этот метод суммирует элементы целочисленного массива.
Выполнение этой программы дает следующий результат:
Рассмотрим подробнее эту программу. В ней определены три класса. Имя первого — SumArray. В нем содержится метод sumArray(), вычисляющий сумму элементов целочисленного массива. Во втором классе MyThread используется статический объект sa типа SumArray для получения суммы элементов массива. А поскольку он статический, то все экземпляры класса MyThread используют одну его копию. И наконец, в классе Sync создаются два потока, в каждом из которых должна вычисляться сумма элементов массива.
В методе sumArray() вызывается метод sleep(). Он нужен лишь для того, чтобы обеспечить переключение задач. Метод sumArray() синхронизирован, и поэтому в каждый момент времени он может использоваться только одним потоком. Следовательно, когда второй порожденный поток начинает свое исполнение, он не может вызвать метод sumArray() до тех пор, пока этот метод не завершится в первом потоке. Благодаря этому обеспечивается правильность получаемого результата.
Для того чтобы лучше понять эффект от использования ключевого слова synchronized, попробуйте удалить его из объявления метода sumArray(). В итоге метод sumArray() потеряет синхронизацию и может быть использован в нескольких потоках одновременно. Это приведет к затруднению в связи с тем, что результат расчета суммы сохраняется в переменной sum, значение которой изменяется при каждом вызове метода sumArray() для статического объекта sa. Так, если в двух потоках одновременно сделать вызов sa. sumArray(), расчет суммы окажется неверным, поскольку в переменной sum накапливаются результаты суммирования, выполняемого одновременно в двух потоках. Ниже приведен результат выполнения той же самой программы, где из объявления метода sumArray() удалено ключевое слово synchronized. (Вследствие отличий в вычислительных средах у вас может получиться несколько иной результат.)
Нетрудно заметить, что вследствие одновременного вызова sa. sumArray() из разных потоков результат искажается.
Прежде чем переходить к рассмотрению следующей темы, перечислим основные свойства синхронизированных методов.
- Синхронизированный метод создается путем указания ключевого слова synchronized в его объявлении.
- Как только синхронизированный метод любого объекта получает управление, объект блокируется и ни один синхронизированный метод этого объекта не может быть вызван другим потоком.
- Потоки, которым требуется синхронизированный метод, используемый другим потоком, ожидают до тех пор, пока не будет разблокирован объект, для которого он вызывается.
- Когда синхронизированный метод завершается, разблокируется объект, для которого он вызывается.
Несмотря на то что создание синхронизированных методов в классах — простой и эффективный способ управления потоками, такой способ оказывается пригодным далеко не всегда. Иногда возникает потребность синхронизировать доступ к методам, в объявлении которых отсутствует ключевое слово synchronized. Подобная ситуация часто возникает при использовании классов, которые были созданы независимыми разработчиками и исходный код которых недоступен. В таком случае ввести в объявление нужного метода ключевое слово synchronized вряд ли удастся. Как же тогда синхронизировать объект класса, содержащего этот метод? К счастью, данное затруднение разрешается очень просто. Достаточно ввести вызов метода в синхронизированный кодовый блок типа synchronized.
Синхронизированный блок определяется следующим образом:
где ссылка_на_объект обозначает ссылку на конкретный объект, который должен быть синхронизирован. Как только содержимое синхронизированного блока получит управление, ни один другой поток не сможет вызвать метод для объекта, на который делается ссылка_на_объект9 до тех пор, пока этот кодовый блок не завершится.
Следовательно, обращение к методу sumArray() можно синхронизировать, вызвав его из синхронизированного блока. Такой способ демонстрируется в приведенной ниже переделанной версии предыдущей программы.
Выполнение этой версии программы дает такой же правильный результат, как и предыдущей ее версии, в которой использовался синхронизированный метод.
Организация взаимодействия потоков с помощью методов notify(), wait() и notifyAll()
Рассмотрим для примера следующую ситуацию. В потоке Т выполняется синхронизированный метод, которому необходим доступ к ресурсу R. Этот ресурс временно недоступен. Что должен предпринять поток т? Если он будет ожидать в цикле освобождения ресурса R, объект будет по-прежнему заблокирован и другие потоки не смогут обратиться к нему. Такое решение малопригодно, поскольку оно сводит на нет все преимущества программирования в многопоточной среде. Намного лучше, если поток Т временно разблокирует объект и позволит другим потокам воспользоваться его методами. Когда ресурс R станет доступным, поток т получит об этом уведомление и возобновит свое исполнение. Но для того чтобы такое решение можно было реализовать, необходимы средства взаимодействия потоков, с помощью которых один поток мог бы уведомить другой поток о том, что он приостановил свое исполнение, а также получить уведомление о том, что его исполнение может быть возобновлено. Для организации подобного взаимодействия потоков в Java предусмотрены методы wait(), notify() и notifyAll().
Эти методы реализованы в классе Object, поэтому они доступны для любого объекта. Но обратиться к ним можно только из синхронизированного контекста. А применяются они следующим образом. Когда поток временно приостанавливает свое исполнение, он вызывает метод wait(). При этом поток переходит в состояние ожидания и монитор данного объекта освобождается, позволяя другим потокам использовать объект. Впоследствии ожидающий поток возобновит свое выполнение, когда другой поток войдет в тот же самый монитор и вызовет метод notify() или notifyAll().
В классе Object определены различные формы объявления метода wait(), как показано ниже.
В первой своей форме метод wait() переводит поток в режим ожидания до поступления уведомления. Во второй форме метода организуется ожидание уведомления или до тех пор, пока не истечет указанный период времени. А третья форма позволяет точнее задавать период времени в наносекундах.
Ниже приведены общие формы объявления методов notify() и notifyAll().
При вызове метода notify() возобновляется исполнение одного ожидающего потока. А метод notifyAll() уведомляет все потоки об освобождении объекта, и тот поток, который имеет наивысший приоритет, получает доступ к объекту.
Прежде чем рассматривать конкретный пример, демонстрирующий применение метода wait(), необходимо сделать важное замечание. Несмотря на то что метод wait() должен переводить поток в состояние ожидания до тех пор, пока не будет вызван метод notify() или notifyAll(), иногда поток выводится из состояния ожидания вследствие так называемой ложной активизации. Условия для ложной активизации сложны, возникают редко, а их обсуждение выходит за рамки этой книги. Но в компании Oracle рекомендуют учитывать вероятность проявления ложной активизации и помещать вызов метода wait() в цикл. В этом цикле должно проверяться условие, по которому поток переводится в состояние ожидания. Именно такой подход и применяется в рассматриваемом ниже примере.
Пример применения методов wait() и notify()
Для того чтобы стала понятнее потребность в применении методов wait() и notify() в многопоточном программировании, рассмотрим пример программы, имитирующей работу часов и выводящей на экран слова «Tick» (Тик) и «Тоск» (Так). Для этой цели создадим класс TickTock, который будет содержать два метода: tick() и tock(). Метод tick() выводит слово «Tick», а метод tock() — слово «Тоск». При запуске программы, имитирующей часы, создаются два потока: в одном из них вызывается метод tick(), а в другом — метод tock(). В результате взаимодействия двух потоков на экран будет выводиться набор повторяющихся сообщений «Tick Tock», т.е. после слова «Tick», обозначающего один такт, должно следовать слово «Тоск», обозначающее другой такт часов.
В результате выполнения этой программы на экране появляются следующие сообщения:
Рассмотрим более подробно исходный код программы, имитирующей работу часов. В ее основу положен класс TickTock. В нем содержатся два метода tick() и tock(), которые взаимодействуют друг с другом. Это взаимодействие организовано таким образом, чтобы за словом «Tick” всегда следовало слово «Tock», затем слово «Tick» и т.д. Обратите внимание на переменную state. В процессе работы имитатора часов в данной переменной хранится строка «ticked» или «tocked», определяющая текущее состояГлава 1 1. Многопоточное программирование 41.1 ние часов после такта “тик” или/‘так” соответственно. В методе main() создается объект tt типа TickTock, используемый для запуска двух потоков на исполнение.
Потоки строятся на основе объектов типа MyThread. Конструктору MyThread() передаются два параметра. Первый из них задает имя потока (в данном случае — «Tick» или «Тоск»), а второй — ссылку на объект типа TickTock (в данном случае — объект tt). В методе run() из класса MyThread вызывается метод tick(), если поток называется «Tick», или же метод tock(), если поток называется «Тоск». Каждый из этих методов вызывается пять раз с параметром, принимающим логическое значение true. Работа имитатора часов продолжается до тех пор, пока методу передается параметр с логическим значением true. Последний вызов каждого из методов с параметром, принимающим логическое значение false, останавливает имитатор работы часов.
Самая важная часть программы находится в теле методов tick() и tock() из класса TickTock. Начнем с метода tick(). Для удобства анализа ниже представлен исходный код этого метода.
Прежде всего обратите внимание на то, что в объявлении метода tick() присутствует ключевое слово synchronized, указываемое в качестве модификатора доступа. Как пояснялось ранее, действие методов wait() и notify() распространяется только на синхронизированные методы. В начале метода tick() проверяется значение параметра running. Этот параметр служит для корректного завершения программы, имитирующей работу часов. Если он принимает логическое значение false, имитатор работы часов должен быть остановлен. Если же параметр running принимает логическое значение true, а переменная state — значение «ticked», вызывается метод notify(), разрешающий ожидающему потоку возобновить свое исполнение. Мы еще вернемся к этому вопросу несколько ниже.
По ходу работы имитируемых часов в методе tick() выводится слово «Tick», переменная state принимает значение «ticked», а затем вызывается метод notify(). Вызов метода notify() возобновляет исполнение ожидающего потока. Далее в цикле while вызывается метод wait(). В итоге выполнение метода tick() будет приостановлено до тех пор, пока другой поток не вызовет метод notify(). Таким образом, очередной шаг цикла не будет выполнен до тех пор, пока другой поток не вызовет метод notify() для того же самого объекта. Поэтому когда вызывается метод tick(), на экран выводится слово «Tick» и другой поток получает возможность продолжить свое исполнение, а затем выполнение этого метода приостанавливается.
В том цикле while, в котором вызывается метод wait(), проверяется значение переменной state. Значение «tocked», означающее завершение цикла, будет установлено только после выполнения метода tock(). Этот цикл предотвращает продолжение исполнения потока в результате ложной активизации. Если по окончании ожидания в переменной state не будет присутствовать значение «tocked», значит, имела место ложная активизация, и метод wait() будет вызван снова.
Метод tock() является почти точной копией метода tick(). Его отличие состоит лишь в том, что он выводит на экран слово «Tock» и присваивает переменной state значение «tocked». Следовательно, когда метод tock() вызывается, он выводит на экран слово «Tock», вызывает метод notify(), а затем переходит в состояние ожидания. Если проанализировать работу сразу двух потоков, то станет ясно, что за вызовом метода tick() тотчас следует вызов метода tock(), после чего снова вызывается метод tick(), и т.д. В итоге оба метода синхронизируют друг друга.
При остановке имитатора работы часов вызывается метод not if у (). Это нужно для того, чтобы возобновить исполнение ждущего потока. Как упоминалось выше, в обоих методах, tick() и tock(), после вывода сообщения на экран вызывается метод wait(). В результате при остановке имитатора работы часов один из потоков обязательно будет находиться в состоянии ожидания. Следовательно, последний вызов метода notify() необходим. В качестве эксперимента попробуйте удалить вызов метода notify() и посмотрите, что при этом произойдет. Вы увидите, что программа зависнет, и вам придется завершить ее нажатием комбинации клавиш <Ctrl+C>. Дело в том, что когда метод tock() в последний раз получает управление, он вызывает метод wait(), после чего не происходит вызов метода not if у (), позволяющего завершиться методу tock(). В итоге метод tock() остается в состоянии бесконечного ожидания.
Если у вас еще остаются сомнения по поводу того, что методы wait() и notify() необходимы для организации нормального выполнения программы, имитирующей работу часов, замените в ее исходном коде класс TickTock приведенным ниже его вариантом. Он отличается тем, что в нем удалены вызовы методов wait() и notify().
Теперь программа выводит на экран следующие сообщения:
Это происходит потому, что методы tick() и tock() не взаимодействуют друг с другом.
Приостановка, возобновление и остановка потоков
Иногда оказывается полезно приостановить или даже полностью прекратить исполнение потока. Допустим, отдельный поток используется для отображения времени. Если пользователю не нужны часы на экране, то отображающий их поток можно приостановить. Независимо от причин, по которым требуется временная остановка потока, сделать это нетрудно, как, впрочем, и возобновить исполнение потока.
Механизмы приостановки, возобновление и остановки потоков менялись в разных версиях Java. До появления версии Java 2 для этих целей применялись методы suspend(), resume() и stop(), определенные в классе Thread. Ниже приведены общие формы их объявления.
На первый взгляд кажется, что упомянутые выше методы удобны для управления потоками, но пользоваться ими все же не рекомендуется по следующим причинам. При выполнении метода suspend() иногда возникают серьезные осложнения, приводящие к взаимоблокировке. Метод resume() сам по себе безопасен, но применяется только в сочетании с методом suspend(). Что же касается метода stop() из класса Thread, то и он не рекомендуется к применению, начиная с версии Java 2, поскольку может вызывать порой серьезные осложнения в работе многопоточных программ.
Если методы suspend(), resume() и stop() нельзя использовать для управления потоками, то может показаться, что приостановить, возобновить и остановить поток вообще нельзя. Но это, к счастью, не так. Поток следует разрабатывать таким образом, чтобы в методе run() периодически осуществлялась проверка, следует ли приостановить, возобновить или остановить поток. Обычно для этой цели используются две флаговые переменные: одна — для приостановки и возобновления потока, другая — для остановки потока. Если флаговая переменная, управляющая приостановкой потока, установлена в состояние исполнения, то метод run() должен обеспечить продолжение исполнения потока. Если же эта флаговая переменная находится в состоянии приостановки, в работе потока должна произойти пауза. А если переменная, управляющая остановкой потока, находится в состоянии остановки, исполнение потока должно прекратиться.
Следующий пример программы демонстрирует один из способов реализации собственных версий методов suspend(), resume() и stop().
Ниже приведен результат выполнения данной программы.
Эта программа работает следующим образом. В классе потока MyThread определены две логические переменные, suspended и stopped, управляющие временной и полной остановкой потока. В конструкторе этого класса обеим переменным присваивается логическое значение false. Метод run() содержит синхронизированный блок, в котором проверяется состояние переменной suspended. Если эта переменная принимаетлогическое значение true, вызывается метод wait(), приостанавливающий исполнение потока. Логическое значение true присваивается переменной suspended в методе mysuspend(), и поэтому данный метод следует вызвать для приостановки потока. Для возобновления потока служит метод myresume(), в котором переменной suspended присваивается логическое значение false и вызывается метод not if у ().
Для остановки потока следует вызвать метод my stop(), в котором переменной stopped присваивается логическое значение true. Кроме того, в методе mystop() переменной suspended присваивается логическое значение false и вызывается метод notify(). Это необходимо для прекращения работы потока, исполнение которого ранее было приостановлено.
В отношении рассматриваемой здесь программы нужно сделать еще одно, последнее замечание. В объявлении переменных suspended и stopped используется ключевое слово volatile. Этот модификатор подробно описывается в главе 14, а до тех пор вкратце поясним его назначение. Он сообщает компилятору о том, что значение переменной может быть неожиданно изменено другими частями программы, в том числе и другим потоком.
Пример для опробования 11.2. Применение основного потока
В каждой программе на Java присутствует хотя бы один поток, называемый основным. Этот поток получает управление автоматически при запуске программы на выполнение. В этом проекте будет продемонстрировано, что основным потоком можно управлять таким образом же, как и любым другим.
Чем процесс отличается от потока?
Потоки выполнения процесса можно уподобить нескольким вместе работающим поварам. Все они готовят одно блюдо, читают одну и ту же кулинарную книгу с одним и тем же рецептом и следуют его указаниям, причём необязательно все они читают на одной и той же странице.
| Поток | Процесс |
|---|---|
| Поток имеет стэк – свою память для исполнения. | Процесс – это совокупность кода и данных, финкционирующих в виртуальном (адресном) пространстве. |
| Потоки выполнения существуют как составные элементы процессов. | Процессы, как правило, независимы. |
| Несколько потоков выполнения внутри процесса совместно используют информацию о состоянии, а также память и другие вычислительные ресурсы. | Несут значительно больше информации о состоянии. |
| Потоки выполнения совместно используют их адресное пространство. | Операционная система (ОС) для каждого процесса создает своё, так называемое «виртуальное адресное пространство» в памяти, к которому процесс имеет прямой доступ. |
| Взаимодействуют только через предоставляемые системой механизмы связей между процессами (файлы, каналы связи..) | |
| Переключение контекста между потоками выполнения в одном процессе, как правило, быстрее, чем переключение контекста между процессами. | |
| Потоки расходуют существенно меньше ресурсов, чем процессы, в процессе выполнения работы выгоднее создавать дополнительные потоки и избегать создания новых процессов. |
Когда запускается любое приложение, то начинает выполняться поток, называемый главным потоком (main). От него порождаются дочерние потоки.
Главный поток, как правило, является последним потоком, завершающим выполнение программы.
Несмотря на то, что главный поток создаётся автоматически, им можно управлять через объект класса Thread. Для этого нужно вызвать метод currentThread(), после чего можно управлять потоком.
Класс Thread содержит несколько методов для управления потоками:
В нем пишется выполняемый код
Запускает переопределенный метод run()
* Если просто запустить run() не будет параллельности выполнения — просто выполниться метод run().
Многопоточность в Java
Здравствуйте! В этой статье я вкратце расскажу вам о процессах, потоках, и об основах многопоточного программирования на языке Java. 
Наиболее очевидная область применения многопоточности – это программирование интерфейсов. Многопоточность незаменима тогда, когда необходимо, чтобы графический интерфейс продолжал отзываться на действия пользователя во время выполнения некоторой обработки информации. Например, поток, отвечающий за интерфейс, может ждать завершения другого потока, загружающего файл из интернета, и в это время выводить некоторую анимацию или обновлять прогресс-бар. Кроме того он может остановить поток загружающий файл, если была нажата кнопка «отмена».
Еще одна популярная и, пожалуй, одна из самых хардкорных областей применения многопоточности – игры. В играх различные потоки могут отвечать за работу с сетью, анимацию, расчет физики и т.п.
Давайте начнем. Сначала о процессах.
Процессы
Процесс — это совокупность кода и данных, разделяющих общее виртуальное адресное пространство. Чаще всего одна программа состоит из одного процесса, но бывают и исключения (например, браузер Chrome создает отдельный процесс для каждой вкладки, что дает ему некоторые преимущества, вроде независимости вкладок друг от друга). Процессы изолированы друг от друга, поэтому прямой доступ к памяти чужого процесса невозможен (взаимодействие между процессами осуществляется с помощью специальных средств).
Для каждого процесса ОС создает так называемое «виртуальное адресное пространство», к которому процесс имеет прямой доступ. Это пространство принадлежит процессу, содержит только его данные и находится в полном его распоряжении. Операционная система же отвечает за то, как виртуальное пространство процесса проецируется на физическую память.
Схема этого взаимодействия представлена на картинке. Операционная система оперирует так называемыми страницами памяти, которые представляют собой просто область определенного фиксированного размера. Если процессу становится недостаточно памяти, система выделяет ему дополнительные страницы из физической памяти. Страницы виртуальной памяти могут проецироваться на физическую память в произвольном порядке.
При запуске программы операционная система создает процесс, загружая в его адресное пространство код и данные программы, а затем запускает главный поток созданного процесса.
Потоки
Один поток – это одна единица исполнения кода. Каждый поток последовательно выполняет инструкции процесса, которому он принадлежит, параллельно с другими потоками этого процесса.
Следует отдельно обговорить фразу «параллельно с другими потоками». Известно, что на одно ядро процессора, в каждый момент времени, приходится одна единица исполнения. То есть одноядерный процессор может обрабатывать команды только последовательно, по одной за раз (в упрощенном случае). Однако запуск нескольких параллельных потоков возможен и в системах с одноядерными процессорами. В этом случае система будет периодически переключаться между потоками, поочередно давая выполняться то одному, то другому потоку. Такая схема называется псевдо-параллелизмом. Система запоминает состояние (контекст) каждого потока, перед тем как переключиться на другой поток, и восстанавливает его по возвращению к выполнению потока. В контекст потока входят такие параметры, как стек, набор значений регистров процессора, адрес исполняемой команды и прочее…
Проще говоря, при псевдопараллельном выполнении потоков процессор мечется между выполнением нескольких потоков, выполняя по очереди часть каждого из них.
Вот как это выглядит:
Цветные квадраты на рисунке – это инструкции процессора (зеленые – инструкции главного потока, синие – побочного). Выполнение идет слева направо. После запуска побочного потока его инструкции начинают выполняться вперемешку с инструкциями главного потока. Кол-во выполняемых инструкций за каждый подход не определено.
То, что инструкции параллельных потоков выполняются вперемешку, в некоторых случаях может привести к конфликтам доступа к данным. Проблемам взаимодействия потоков будет посвящена следующая статья, а пока о том, как запускаются потоки в Java…
Запуск потоков
Каждый процесс имеет хотя бы один выполняющийся поток. Тот поток, с которого начинается выполнение программы, называется главным. В языке Java, после создания процесса, выполнение главного потока начинается с метода main(). Затем, по мере необходимости, в заданных программистом местах, и при выполнении заданных им же условий, запускаются другие, побочные потоки.
В языке Java поток представляется в виде объекта-потомка класса Thread. Этот класс инкапсулирует стандартные механизмы работы с потоком.
Запустить новый поток можно двумя способами:
Способ 1
Создать объект класса Thread, передав ему в конструкторе нечто, реализующее интерфейс Runnable. Этот интерфейс содержит метод run(), который будет выполняться в новом потоке. Поток закончит выполнение, когда завершится его метод run().
Выглядит это так:
Для пущего укорочения кода можно передать в конструктор класса Thread объект безымянного внутреннего класса, реализующего интерфейс Runnable:
Способ 2
Создать потомка класса Thread и переопределить его метод run():
В приведённом выше примере в методе main() создается и запускается еще один поток. Важно отметить, что после вызова метода mSecondThread.start() главный поток продолжает своё выполнение, не дожидаясь пока порожденный им поток завершится. И те инструкции, которые идут после вызова метода start(), будут выполнены параллельно с инструкциями потока mSecondThread.
Для демонстрации параллельной работы потоков давайте рассмотрим программу, в которой два потока спорят на предмет философского вопроса «что было раньше, яйцо или курица?». Главный поток уверен, что первой была курица, о чем он и будет сообщать каждую секунду. Второй же поток раз в секунду будет опровергать своего оппонента. Всего спор продлится 5 секунд. Победит тот поток, который последним изречет свой ответ на этот, без сомнения, животрепещущий философский вопрос. В примере используются средства, о которых пока не было сказано (isAlive() sleep() и join()). К ним даны комментарии, а более подробно они будут разобраны дальше.
В приведенном примере два потока параллельно в течении 5 секунд выводят информацию на консоль. Точно предсказать, какой поток закончит высказываться последним, невозможно. Можно попытаться, и можно даже угадать, но есть большая вероятность того, что та же программа при следующем запуске будет иметь другого «победителя». Это происходит из-за так называемого «асинхронного выполнения кода». Асинхронность означает то, что нельзя утверждать, что какая-либо инструкция одного потока, выполнится раньше или позже инструкции другого. Или, другими словами, параллельные потоки независимы друг от друга, за исключением тех случаев, когда программист сам описывает зависимости между потоками с помощью предусмотренных для этого средств языка.
Теперь немного о завершении процессов…
Завершение процесса и демоны
В Java процесс завершается тогда, когда завершается последний его поток. Даже если метод main() уже завершился, но еще выполняются порожденные им потоки, система будет ждать их завершения.
Однако это правило не относится к особому виду потоков – демонам. Если завершился последний обычный поток процесса, и остались только потоки-демоны, то они будут принудительно завершены и выполнение процесса закончится. Чаще всего потоки-демоны используются для выполнения фоновых задач, обслуживающих процесс в течение его жизни.
Объявить поток демоном достаточно просто — нужно перед запуском потока вызвать его метод setDaemon(true) ;
Проверить, является ли поток демоном, можно вызвав его метод boolean isDaemon() ;
Завершение потоков
В Java существуют (существовали) средства для принудительного завершения потока. В частности метод Thread.stop() завершает поток незамедлительно после своего выполнения. Однако этот метод, а также Thread.suspend(), приостанавливающий поток, и Thread.resume(), продолжающий выполнение потока, были объявлены устаревшими и их использование отныне крайне нежелательно. Дело в том что поток может быть «убит» во время выполнения операции, обрыв которой на полуслове оставит некоторый объект в неправильном состоянии, что приведет к появлению трудноотлавливаемой и случайным образом возникающей ошибке.
Вместо принудительного завершения потока применяется схема, в которой каждый поток сам ответственен за своё завершение. Поток может остановиться либо тогда, когда он закончит выполнение метода run(), (main() — для главного потока) либо по сигналу из другого потока. Причем как реагировать на такой сигнал — дело, опять же, самого потока. Получив его, поток может выполнить некоторые операции и завершить выполнение, а может и вовсе его проигнорировать и продолжить выполняться. Описание реакции на сигнал завершения потока лежит на плечах программиста.
Java имеет встроенный механизм оповещения потока, который называется Interruption (прерывание, вмешательство), и скоро мы его рассмотрим, но сначала посмотрите на следующую программку:
Incremenator — поток, который каждую секунду прибавляет или вычитает единицу из значения статической переменной Program.mValue. Incremenator содержит два закрытых поля – mIsIncrement и mFinish. То, какое действие выполняется, определяется булевой переменной mIsIncrement — если оно равно true, то выполняется прибавление единицы, иначе — вычитание. А завершение потока происходит, когда значение mFinish становится равно true.
Несмотря на то, что метод sleep() может принимать в качестве времени ожидания наносекунды, не стоит принимать это всерьез. Во многих системах время ожидания все равно округляется до миллисекунд а то и до их десятков.
Метод yield()
Статический метод Thread.yield() заставляет процессор переключиться на обработку других потоков системы. Метод может быть полезным, например, когда поток ожидает наступления какого-либо события и необходимо чтобы проверка его наступления происходила как можно чаще. В этом случае можно поместить проверку события и метод Thread.yield() в цикл:
Метод join()
В Java предусмотрен механизм, позволяющий одному потоку ждать завершения выполнения другого. Для этого используется метод join(). Например, чтобы главный поток подождал завершения побочного потока myThready, необходимо выполнить инструкцию myThready.join() в главном потоке. Как только поток myThready завершится, метод join() вернет управление, и главный поток сможет продолжить выполнение.
Метод join() имеет перегруженную версию, которая получает в качестве параметра время ожидания. В этом случае join() возвращает управление либо когда завершится ожидаемый поток, либо когда закончится время ожидания. Подобно методу Thread.sleep() метод join может ждать в течение миллисекунд и наносекунд – аргументы те же.
С помощью задания времени ожидания потока можно, например, выполнять обновление анимированной картинки пока главный (или любой другой) поток ждёт завершения побочного потока, выполняющего ресурсоёмкие операции:
В этом примере поток brain (мозг) думает над чем-то, и предполагается, что это занимает у него длительное время. Главный поток ждет его четверть секунды и, в случае, если этого времени на раздумье не хватило, обновляет «индикатор раздумий» (некоторая анимированная картинка). В итоге, во время раздумий, пользователь наблюдает на экране индикатор мыслительного процесса, что дает ему знать, что электронные мозги чем то заняты.
Приоритеты потоков
Каждый поток в системе имеет свой приоритет. Приоритет – это некоторое число в объекте потока, более высокое значение которого означает больший приоритет. Система в первую очередь выполняет потоки с большим приоритетом, а потоки с меньшим приоритетом получают процессорное время только тогда, когда их более привилегированные собратья простаивают.
Работать с приоритетами потока можно с помощью двух функций:
void setPriority(int priority) – устанавливает приоритет потока.
Возможные значения priority — MIN_PRIORITY, NORM_PRIORITY и MAX_PRIORITY.
int getPriority() – получает приоритет потока.
Некоторые полезные методы класса Thread
Это практически всё. Напоследок приведу несколько полезных методов работы с потоками.
boolean isAlive() — возвращает true если myThready() выполняется и false если поток еще не был запущен или был завершен.
setName(String threadName) – Задает имя потока.
String getName() – Получает имя потока.
Имя потока – ассоциированная с ним строка, которая в некоторых случаях помогает понять, какой поток выполняет некоторое действие. Иногда это бывает полезным.
static Thread Thread.currentThread() — статический метод, возвращающий объект потока, в котором он был вызван.
long getId() – возвращает идентификатор потока. Идентификатор – уникальное число, присвоенное потоку.
Заключение
Отмечу, что в статье рассказано далеко не про все нюансы многопоточного программирования. И коду, приведенному в примерах, для полной корректности не хватает некоторых нюансов. В частности, в примерах не используется синхронизация. Синхронизация потоков — тема, не изучив которую, программировать правильные многопоточные приложения не получится. Почитать о ней вы можете, например, в книге «Java Concurrency in Practice» или здесь (всё на английском).
В статье были рассмотрены основные средства работы с потоками в Java. Если эта статья окажется полезной, то в следующей я расскажу о проблемах совместного доступа потоков к ресурсам и о методах их решения.