Почему бывают нужны потоки выполнения? Представьте себе программу управления спектрометром, в которой одно табло должно показывать время, прошедшее с начала измерений, второе – число импульсов со счётчика установки, третье – длину волны, для которой в данный момент идут измерения. Кроме того, в фоновом режиме должен отрисовываться получающийся после обработки данных спектр. Возможны две идеологии работы программы – последовательная и параллельная. При последовательном подходе во время выполнения алгоритмов, связанных с показом информации на экране, следует время от времени проверять, не пришли ли новые импульсы со счётчиков, и не надо ли установить спектрометр на очередную длину волны. Кроме того, во время обработки данных и отрисовки спектра следует через определённые промежутки обновлять табло времени и счётчиков.
В результате код программы перестаёт быть структурным. Нарушается принцип инкапсуляции – “независимые вещи должны быть независимы”. Независимые по логике решаемой проблемы алгоритмы оказываются перемешаны друг с другом. Такой код оказывается ненадёжным и плохо модифицируемым. Однако он относительно легко отлаживается, поскольку последовательность выполнения операторов программы однозначно определена.
В параллельном варианте для каждого из независимых алгоритмов запускается свой поток выполнения, и ему задаётся необходимый приоритет. В нашем случае один (или более) поток занимается измерениями. Второй – показывает время, прошедшее с начала измерений, третий – число импульсов со счётчика, четвёртый – длину волны. Пятый поток рисует спектр. Каждый из них занят своим делом и не вмешивается в другой. Связь между потоками идёт только через данные, которые первый поток поставляет остальным.
Несмотря на изящество параллельной модели, у неё имеются очень неприятные недостатки.
Во-первых, негарантированное время отклика. Например, при использовании потоков для анимации графических объектов может наблюдался сбой равномерности движения объекта.
Во-вторых, отладка программ, работающих с использованием параллелизма, с помощью традиционных средств практически невозможна. Если при каком-то сочетании условий по времени происходит ошибка, воспроизвести её обычно оказывается невозможно: воссоздать те же временные интервалы крайне сложно. Поэтому требуется применять специальные технологии с регистрацией всех потоков данных в файлы с отладочной информацией. Для этих целей, а также для нахождения участков кода, вызывающих наибольшую трату времени и ресурсов во время выполнения приложения, используются специальные программы – профилировщики (profilers).
Синхронизация по ресурсам и событиям
Использование потоков выполнения порождает целый ряд проблем не только в плане отладки программ, но и при организации взаимодействия между разными потоками.
Синхронизация по ресурсам
Если разные потоки получают доступ к одним и тем же данным, причём один из них или они оба меняют эти данные, для них требуется обеспечить установить разграничение доступа. Пока один поток меняет данные, второй не должен иметь права их читать или менять. Он должен дожидаться окончания доступа к данным первого потока. Говорят, что осуществляется синхронизация потоков. В Java для этих целей служит оператор synchronize (“синхронизировать”). Такой тип синхронизации называется синхронизацией по ресурсам и обеспечивает блокировку данных на то время, которое необходимо потоку для выполнения тех или иных действий. В Java такого рода блокировка осуществляется на основе концепции мониторов и в применении к Java заключается в следующем. Под монитором понимается некая управляющая конструкция, обеспечивающая монопольный доступ к объекту. Если во время выполнения синхронизованного метода объекта другой поток попробует обратиться к методам или данным этого объекта, он будет блокирован до тех пор, пока не закончится выполнение синхронизованного метода. При запуске синхронизованного метода говорят, что объект входит в монитор, при завершении – что объект выходит из монитора. При этом поток, внутри которого вызван синхронизованный метод, считается владельцем данного монитора.
Имеется два способа синхронизации по ресурсам: синхронизация объекта и синхронизация метода.
Синхронизация объекта obj1 (его иногда называют объектом действия) осуществляется следующим образом:
synchronized(obj1) оператор;
Например:
synchronized(obj1){
...
m1(obj1);
...
obj1.m2();
...
}
В данном случае в качестве синхронизованного оператора выступает участок кода в фигурных скобках. Во время выполнения этого участка доступ к объекту obj1 блокируется для всех других потоков. Это означает, что пока будет выполняться вызов оператора, выполнение вызова любого синхронизованного метода или синхронизованного оператора для этого объекта будет приостановлено до окончания работы оператора.
Данный способ синхронизации обычно используется для экземпляров классов, разработанных без расчёта на работу в режиме многопоточности.
Второй способ синхронизации по ресурсам используется при разработке класса, рассчитанного на взаимодействия в многопоточной среде. При этом методы, критичные к атомарности операций с данными (обычно - требующие согласованное изменение нескольких полей данных), объявляются как синхронизованные с помощью модификатора synchronized:
public class ИмяКласса {
...
public synchronized тип метод (...){
...
}
}
Вызов данного метода из объекта приведёт к вхождению данного объекта в монитор.
Пример:
public class C1{
public synchronized void m1(){
}
}
C1 obj1=new C1();
obj1.m1();
Пока будет выполняться вызов obj1.m1(), доступ из других потоков к объекту obj1 будет блокирован – выполнение вызова любого синхронизованного метода или синхронизованного оператора для этого объекта будет приостановлено до окончания работы метода m1().
Если синхронизованный метод является не методом объекта, а методом класса, при вызове метода в монитор входит класс, и приостановка до окончания работы метода будет относиться ко всем вызовам синхронизованных методов данного класса.
Итак, возможна синхронизация как целого метода (но только при задании его реализации в классе), так и отдельных операторов. Иногда синхронизованную область кода (метод или оператор) называют критической секцией кода.
Синхронизация по событиям
Кроме синхронизации по данным имеется синхронизация по событиям, когда параллельно выполняющиеся потоки приостанавливаются вплоть до наступления некоторого события, о котором им сигнализирует другой поток. Основными операциями при таком типе синхронизации являются wait (“ждать”) и notify (“оповестить”).
В Java синхронизацию по событиям обеспечивают следующие методы, заданные в классе Object и наследуемые всеми остальными классами:
void wait() – поток, внутри которого какой-либо объект вызвал данный метод (владелец монитора), переводится в состояние ожидания. Поток приостанавливает работу своего метода run() вплоть до поступления объекту, вызвавшему приостановку (“засыпание”) потока уведомления notify() или notifyAll(). При неправильной попытке “разбудить” поток соответствующий код компилируется, но при запуске вызывает появление исключения llegalMonitorStateException.
void wait(long millis) – то же, но ожидание длится не более millis миллисекунд.
void wait(long millis, int nanos) – то же, но ожидание длится не более millis миллисекунд и nanos наносекунд.
void notify() – оповещение, приводящее к возобновлению работы потока, ожидающего выхода данного объекта из монитора. Если таких потоков несколько, выбирается один из них. Какой – зависит от реализации системы.
void notifyAll() - оповещение, приводящее к возобновлению работы всех потоков, ожидающих выхода данного объекта из монитора.
Метод wait для любого объекта obj следует использовать следующим образом - необходимо организовать цикл while, в котором следует выполнять оператор wait:
synchronized(obj){
while(not условие)
obj.wait();
…//выполнение операторов после того, как условие стало true
}
При этом не следует беспокоиться, что цикл while постоянно крутится и занимает много ресурсов процессора. Этого не происходит: после вызова obj.wait() поток, в котором находится указанный код, “засыпает” и перестаёт занимать ресурсы процессора. При этом метод wait на время “сна” потока снимает блокировку с объекта obj, задаваемую оператором synchronized(obj). Что позволяет другим потокам обращаться к объекту с вызовом obj.notify() или obj.notifyAll().
