Текст книги "Java: руководство для начинающих (ЛП)"

Автор книги: Герберт Шилдт

сообщить о нарушении

Текущая страница: 24 (всего у книги 36 страниц)

Правда, в классе Thread предусмотрены два средства, позволяющие определить, завершился ли поток. Первым из них является метод is Alive (), объявление которого приведено ниже. final boolean isAlive()

Этот метод возвращает логическое значение true, если поток, для которого он вызывается, все еще исполняется. В противном случае он возвращает логическое значение false. Для того чтобы опробовать метод isAlive () на практике, замените в предыдущей программе класс MoreThreads новой версией, исходный код которой приведен ниже. // Применение метода isAlive(). class MoreThreads { public static void main(String args[]) { System.out.println("Main thread starting."); MyThread mtl = new MyThread("Child #1"); MyThread mt2 = new MyThread("Child #2"); MyThread mt3 = new MyThread("Child #3"); do { System.out.print(" . ") ; try { Thread.sleep(100); } catch(InterruptedException exc) { System.out.println("Main thread interrupted."); } // Ожидание завершения потоков. } while (mtl.thrd.isAlive() || mt2.thrd.isAlive() || mt3.thrd.isAlive()); System.out.println("Main thread ending."); } }

Эта версия дает такой же результат, как и предыдущая. Единственное отличие состоит в том, что в данном случае ожидание завершения порожденного потока организовано с помощью метода isAlive (). Вторым средством, позволяющим определить, завершился ли поток, является метод join (), объявление которого приведено ниже. final void join() throws InterruptedException

Этот метод ожидает завершения потока, для которого он был вызван. Его имя join выбрано потому, что вызывающий поток ожидает, когда указанный поток присоединится (англ.уши) к нему. Имеется и другой вариант метода j oin (), позволяющий указать максимальное время ожидания момента, когда поток завершится.

В приведенном ниже примере программы наличие метода join () гарантирует, что основной поток завершит работу последним. // Применение метода join(). class MyThread implements Runnable { Thread thrd; // построить новый поток MyThread(String name) { thrd = new Thread(this, name); thrd.start(); // начать поток } // начать исполнение нового потока public void run() { System.out.println(thrd.getName() + " starting."); try { for(int count=0; count < 10; count++) { Thread.sleep(400); System.out.println("In " + thrd.getName() + ", count is " + count); } } catch(InterruptedException exc) { System.out.println(thrd.getName() + " interrupted."); } System.out.println(thrd.getName() + " terminating."); } } class JoinThreads { public static void main(String args[]) { System.out.println("Main thread starting."); MyThread mtl = new MyThread("Child #1"); MyThread mt2 = new MyThread("Child #2"); MyThread mt3 = new MyThread("Child #3"); try { // Ожидание до тех nop, пока указанный метод не завершится. mtl.thrd.join(); System.out.println("Child #1 joined."); mt2.thrd.join() ; System.out.println("Child #2 joined."); mt3.thrd.join(); System.out.println("Child #3 joined."); } catch(InterruptedException exc) { System.out.println("Main thread interrupted."); } System.out.println("Main thread ending."); } }

Результат выполнения данной программы приведен ниже. Вследствие отличий в вычислительных средах он может получиться у вас несколько иным. Main thread starting. Child #1 starting. Child #2 starting. Child #3 starting. In Child #2, count is 0 In Child #1, count is 0 In Child #3, count is 0 In Child #2, count is 1 In Child #3, count is 1 In Child #1, count is 1 In Child #2, count is 2 In Child #1, count is 2 In Child #3, count is 2 In Child #2, count is 3 In Child #3, count is 3 In Child#1, count is 3 In Child #3, count is 4 In Child #2, count is 4 In Child #1, count is 4 In Child #3, count is 5 In Child #1, count is 5 In Child #2, count is 5 In Child #3, count is 6 In Child #2, count is 6 In Child #1, count is 6 In Child #3, count is 7 In Child #1, count is 7 In Child #2, count is 7 In Child #3, count is 8 In Child #2, count is 8 In Child #1, count is 8 In Child #3, count is 9 Child #3 terminating. In Child #2, count is 9 Child #2 terminating. In Child #1, count is 9 Child #1 terminating. Child #1 joined. Child #2 joined. Child #3 joined. Main thread ending.

Как видите, после того как вызываемый метод j oin () возвращает управление, исполнение потока прекращается. Приоритеты потоков

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

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

При запуске порожденного потока его приоритет устанавливается равным приоритету родительского потока. Изменить приоритет можно, вызвав метод setPriority () из класса Thread. Ниже приведено объявление этого метода, final void setPriority(int уровень)

В качестве параметра уровень данному методу передается новый приоритет для потока. Значение параметра уровень должно находиться в пределах от MIN PRIORITY до MAX PRIORITY. В настоящее время этим константам соответствуют числовые значения от 1 до 10. Для того чтобы восстановить приоритет потока по умолчанию, следует указать значение 5, которому соответствует константа N0RM PRI0RITY. Константы, определяющие приоритеты потоков, определены как static final в классе Thread.

Получить текущий приоритет можно с помощью метода getPriorityO из класса Thread, объявляемого следующим образом: final int getPriority()

Ниже приведен пример программы, демонстрирующий использование двух потоков с разными приоритетами. Потоки создаются как экземпляры класса Priority. В методе run () содержится цикл, отсчитывающий число своих шагов. Этот цикл завершает работу, когда значение счетчика достигает 10000000 или же когда статическая переменная stop принимает логическое значение true. Первоначально переменной stop присваивается логическое значение false, но первый же поток, заканчивающий отсчет, устанавливает в ней логическое значение true. В результате второй поток завершится, как только ему будет выделен квант времени. В цикле производится проверка символьной строки в переменной currentName на совпадение с именем исполняемого потока. Если они не совпадают, это означает, что произошло переключение задач. При этом отображается имя нового потока, которое присваивается переменной currentName. Это дает возможность следить за тем, насколько часто каждый поток получает время ЦП. После остановки обоих потоков выводится число шагов, выполненных в каждом цикле. // Демонстрация потоков с разными приоритетами. class Priority implements Runnable { int count; Thread thrd; static boolean stop = false; static String currentName; /* Построение нового потока. Обратите внимание на то, что конструктор не запускает поток на исполнение. */ Priority(String name) { thrd = new Thread(this, name); count = 0; currentName = name; } // начать исполнение нового потока public void run() { System.out.println(thrd.getName() + " starting."); do { count++; if(currentName.compareTo(thrd.getName()) != 0) { currentName = thrd.getName(); System.out.println("In " + currentName); } // Первый же поток, в котором достигнуто значение 10000000, // завершает остальные потоки. } while(stop == false && count < 10000000); stop = true; System.out.println("n" + thrd.getName() + " terminating."); } } class PriorityDemo { public static void main(String args[]) { Priority mtl = new Priority("High Priority"); Priority mt2 = new Priority("Low Priority"); // задать приоритеты // Поток mtl получает более высокий приоритет, чем поток mt2. mtl.thrd.setPriority(Thread.NORM_PRIORITY+2); mt2.thrd.setPriority(Thread.NORM_PRIORITY-2); // запустить потоки на исполнение mtl.thrd.start(); mt2.thrd.start(); try { mtl.thrd.join(); mt2.thrd.join(); } catch(InterruptedException exc) { System.out.println("Main thread interrupted."); } System.out.println("nHigh priority thread counted to " + mtl.count); System.out.println("Low priority thread counted to " + mt2.count); } }

Результат выполнения данной программы выглядит следующим образом: High Priority starting. In High Priority Low Priority starting. In Low Priority In High Priority High Priority terminating. Low Priority terminating. High priority thread counted to 10000000 Low priority thread counted to 8183

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

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

Главным для синхронизации в Java является понятие монитора, контролирующего доступ к объекту. Монитор реализует принцип блокировки. Если объект заблокирован одним потоком, то он оказывается недоступным для других потоков. В какой-то момент объект разблокируется, и другие потоки могут обращаться к нему.

У каждого объекта в Java имеется свой монитор. Этот механизм встроен в сам язык. Следовательно, все объекты поддаются синхронизации. Для поддержки синхронизации в Java предусмотрено ключевое слово synchronized и ряд вполне определенных методов у каждого из объектов. А поскольку средства синхронизации встроены в язык, то пользоваться ими на практике очень просто – гораздо проще, чем может показаться на первый взгляд. Для многих программ средства синхронизации объектов по сути прозрачны.

Синхронизировать код можно двумя способами. Оба способа рассматриваются ниже, и в обоих используется ключевое слово synchronized. Применение синхронизированных методов

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

Ниже приведен пример программы, демонстрирующий контролируемый доступ к методу sumArray (). Этот метод суммирует элементы целочисленного массива. // Применение ключевого слова synchronize для управления доступом. class SumArray { private int sum; // Метод sumArray() синхронизирован. synchronized int sumArray(int nums[]) { sum = 0; // обнулить сумму for(int i=0; i

Выполнение этой программы дает следующий результат: Child #1 starting. Running total for Child #1 is 1 Child #2 starting. Running total for Child #1 is 3 Running total for Child #1 is 6 Running total for Child #1 is 10 Running total for Child #1 is 15 Sum for Child #1 is 15 Child #1 terminating. Running total for Child #2 is 1 Running total for Child #2 is 3 Running total for Child #2 is 6 Running total for Child #2 is 10 Running total for Child #2 is 15 Sum for Child #2 is 15 Child #2 terminating.

Рассмотрим подробнее эту программу. В ней определены три класса. Имя первого – SumArray. В нем содержится метод sumArray (), вычисляющий сумму элементов целочисленного массива. Во втором классе MyThread используется статический объект sa типа SumArray для получения суммы элементов массива. А поскольку он статический, то все экземпляры класса MyThread используют одну его копию. И наконец, в классе Sync создаются два потока, в каждом из которых должна вычисляться сумма элементов массива.

В методе sumArray () вызывается метод sleep (). Он нужен лишь для того, чтобы обеспечить переключение задач. Метод sumArray () синхронизирован, и поэтому в каждый момент времени он может использоваться только одним потоком. Следовательно, когда второй порожденный поток начинает свое исполнение, он не может вызвать метод sumArray () до тех пор, пока этот метод не завершится в первом потоке. Благодаря этому обеспечивается правильность получаемого результата.

Для того чтобы лучше понять эффект от использования ключевого слова synchronized, попробуйте удалить его из объявления метода sumArray (). В итоге метод sumArray () потеряет синхронизацию и может быть использован в нескольких потоках одновременно. Это приведет к затруднению в связи с тем, что результат расчета суммы сохраняется в переменной sum, значение которой изменяется при каждом вызове метода sumArray () для статического объекта sa. Так, если в двух потоках одновременно сделать вызов sa. sumArray (), расчет суммы окажется неверным, поскольку в переменной sum накапливаются результаты суммирования, выполняемого одновременно в двух потоках. Ниже приведен результат выполнения той же самой программы, где из объявления метода sumArray () удалено ключевое слово synchronized. (Вследствие отличий в вычислительных средах у вас может получиться несколько иной результат.) Child #1 starting. Running total for Child #1 is 1 Child #2 starting Running total for Child #2 is 1 Running total for Child #1 is 3 Running total for Child #2 is 5 Running total for Child #2 is 8 Running total for Child #1 is 11 Running total for Child #2 is 15 Running total for Child #1 is 19 Running total for Child #2 is 24 Sum for Child #2 : Is 24 Child #2 terminating. Running total for Child #1 is 29 Sum for Child #1 : Ls 29 Child #1 terminating.

Нетрудно заметить, что вследствие одновременного вызова sa. sumArray () из разных потоков результат искажается.

Прежде чем переходить к рассмотрению следующей темы, перечислим основные свойства синхронизированных методов.

Синхронизированный метод создается путем указания ключевого слова synchronized в его объявлении.

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

Потоки, которым требуется синхронизированный метод, используемый другим потоком, ожидают до тех пор, пока не будет разблокирован объект, для которого он вызывается.

Когда синхронизированный метод завершается, разблокируется объект, для которого он вызывается. Синхронизированные блоки

Несмотря на то что создание синхронизированных методов в классах – простой и эффективный способ управления потоками, такой способ оказывается пригодным далеко не всегда. Иногда возникает потребность синхронизировать доступ к методам, в объявлении которых отсутствует ключевое слово synchronized. Подобная ситуация часто возникает при использовании классов, которые были созданы независимыми разработчиками и исходный код которых недоступен. В таком случае ввести в объявление нужного метода ключевое слово synchronized вряд ли удастся. Как же тогда синхронизировать объект класса, содержащего этот метод? К счастью, данное затруднение разрешается очень просто. Достаточно ввести вызов метода в синхронизированный кодовый блок типа synchronized.

Синхронизированный блок определяется следующим образом: synchronized{ссылка_на_объект) { // синхронизируемые операторы }

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

Следовательно, обращение к методу sumArray () можно синхронизировать, вызвав его из синхронизированного блока. Такой способ демонстрируется в приведенной ниже переделанной версии предыдущей программы. // Применение синхронизированного блока // для управления доступом к методу sumArray(). class SumArray { private int sum; // Здесь метод sumArray () не синхронизирован. int sumArray(int nums[]) { sum =0; // обнулить сумму for(int i=0; icnums.length; i++) { sum += nums[i]; System.out.println("Running total for " + Thread.currentThread().getName() + " is " + sum); try { Thread.sleep(10); // разрешить переключение задач } catch(InterruptedException exc) { System.out.println("Main thread interrupted."); } } return sum; } } class MyThread implements Runnable { Thread thrd; static SumArray sa = new SumArray(); int a[]; int answer; // построить новый поток MyThread(String name, int nums[]) { thrd = new Thread(this, name); a = nums; thrd.start(); // начать поток } // начать исполнение нового потока public void run() { int sum; System.out.println(thrd.getName() + " starting."); // Здесь вызовы метода sumArray () для объекта sa синхронизированы. synchronized(sa) { answer = sa.sumArray(a); } System.out.println("Sum for " + thrd.getName() + " is " + answer); System.out.println(thrd.getName() + " terminating."); } } class Sync { public static void main(String args[]) { int a [] = {1, 2, 3, 4, 5}; MyThread mtl = new MyThread("Child #1", a); MyThread mt2 = new MyThread("Child #2", a); try { mtl.thrd.join(); mt2.thrd.join(); } catch (InterruptedException exc) { System.out.println("Main thread interrupted."); } } }

Выполнение этой версии программы дает такой же правильный результат, как и предыдущей ее версии, в которой использовался синхронизированный метод. Организация взаимодействия потоков с помощью методов notify (), wait () и notifyAll ()

Рассмотрим для примера следующую ситуацию. В потоке Т выполняется синхронизированный метод, которому необходим доступ к ресурсу R. Этот ресурс временно недоступен. Что должен предпринять поток т? Если он будет ожидать в цикле освобождения ресурса R, объект будет по-прежнему заблокирован и другие потоки не смогут обратиться к нему. Такое решение малопригодно, поскольку оно сводит на нет все преимущества программирования в многопоточной среде. Намного лучше, если поток Т временно разблокирует объект и позволит другим потокам воспользоваться его методами. Когда ресурс R станет доступным, поток т получит об этом уведомление и возобновит свое исполнение. Но для того чтобы такое решение можно было реализовать, необходимы средства взаимодействия потоков, с помощью которых один поток мог бы уведомить другой поток о том, что он приостановил свое исполнение, а также получить уведомление о том, что его исполнение может быть возобновлено. Для организации подобного взаимодействия потоков в Java предусмотрены методы wait (), notify () и notifyAll ().

Эти методы реализованы в классе Object, поэтому они доступны для любого объекта. Но обратиться к ним можно только из синхронизированного контекста. А применяются они следующим образом. Когда поток временно приостанавливает свое исполнение, он вызывает метод wait (). При этом поток переходит в состояние ожидания и монитор данного объекта освобождается, позволяя другим потокам использовать объект. Впоследствии ожидающий поток возобновит свое выполнение, когда другой поток войдет в тот же самый монитор и вызовет метод notify () или notifyAll ().

В классе Object определены различные формы объявления метода wait (), как показано ниже. final void wait() throws InterruptedException final void wait(long миллисекунд) throws InterruptedException final void wait(long миллисекунд, int наносекунд) throws InterruptedException

В первой своей форме метод wait () переводит поток в режим ожидания до поступления уведомления. Во второй форме метода организуется ожидание уведомления или до тех пор, пока не истечет указанный период времени. А третья форма позволяет точнее задавать период времени в наносекундах.

Ниже приведены общие формы объявления методов notify () и notifyAll (). final void notifyO final void 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", обозначающего один такт, должно следовать слово "Тоск", обозначающее другой такт часов. // Применение методов wait() и notifyO для имитации часов, class TickTock { String state; // содержит сведения о состоянии часов synchronized void tick(boolean running) { if (!running) { // остановить часы state = "ticked"; notifyO; // уведомить ожидающие потоки return; } System.out.print("Tick "); state = "ticked"; // установить текущее состояние после такта "тик" notify(); // Метод tick() уведомляет метод tock() // о возможности продолжить выполнение. try { while(!state.equals("tocked") ) wait();// Метод tick() ожидает завершения метода tock(). } catch(InterruptedException exc) { System.out.println("Thread interrupted."); } } synchronized void tock(boolean running) { if(!running) { // остановить часы state = "tocked"; notifyO; // уведомить ожидающие потоки return; } System.out.println("Tock"); state = "tocked"; // установить текущее состояние после такта "так" notifyO; // Метод tock() уведомляет метод tick() // возможности продолжить выполнение. try { while(!state.equals("ticked") ) wait(); // Метод tock() ожидает завершения метода tick(). } catch(InterruptedException exc) { System.out.println("Thread interrupted."); } } } class MyThread implements Runnable { Thread thrd; TickTock ttOb; // построить новый поток MyThread.(String name, TickTock tt) { thrd = new Thread(this, name); ttOb = tt; thrd.start(); // начать поток } // начать исполнение нового потока public void run() { if(thrd.getName().compareTo("Tick") == 0) { for(int i=0; i<5; i++) ttOb.tick(true); ttOb.tick(false); } else { for(int i=0; i<5; i++) ttOb.tock(true); ttOb.tock(false); } } } class ThreadCom { public static void main(String args[]) { TickTock tt = new TickTock(); MyThread mtl = new MyThread("Tick", tt); MyThread mt2 = new MyThread("Tock", tt); try { mtl.thrd.join(); mt2.thrd.join(); } catch(InterruptedException exc) { System.out.println("Main thread interrupted."); } } }

В результате выполнения этой программы на экране появляются следующие сообщения: Tick Tock Tick Tock Tick Tock Tick Tock Tick Tock `

Рассмотрим более подробно исходный код программы, имитирующей работу часов. В ее основу положен класс 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 (). Для удобства анализа ниже представлен исходный код этого метода. synchronized void tick(boolean running) { if(!running) { // остановить часы state = "ticked"; notifyO; // уведомить ожидающие потоки return; } System.out.print("Tick "); state = "ticked"; // установить текущее состояние после такта "тик" notify(); // уведомить метод tock() о возможности продолжить выполнение try { while(!state.equals("tocked") ) wait(); // ожидать завершения метода tock() } catch(InterruptedException exc) { System.out.println("Thread interrupted."); } }

Прежде всего обратите внимание на то, что в объявлении метода 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 (), и т.д. В итоге оба метода синхронизируют друг друга.