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 , и т.д. В итоге оба метода синхронизируют друг друга.

При остановке имитатора работы часов вызывается метод not if у . Это нужно для того, чтобы возобновить исполнение ждущего потока. Как упоминалось выше, в обоих методах, tick и tock , после вывода сообщения на экран вызывается метод wait . В результате при остановке имитатора работы часов один из потоков обязательно будет находиться в состоянии ожидания. Следовательно, последний вызов метода notify необходим. В качестве эксперимента попробуйте удалить вызов метода notify и посмотрите, что при этом произойдет. Вы увидите, что программа зависнет, и вам придется завершить ее нажатием комбинации клавиш . Дело в том, что когда метод tock в последний раз получает управление, он вызывает метод wait , после чего не происходит вызов метода not if у , позволяющего завершиться методу tock . В итоге метод tock остается в состоянии бесконечного ожидания.

Если у вас еще остаются сомнения по поводу того, что методы wait и notify необходимы для организации нормального выполнения программы, имитирующей работу часов, замените в ее исходном коде класс TickTock приведенным ниже его вариантом. Он отличается тем, что в нем удалены вызовы методов wait и notify . // В этой версии вызовы методов wait и notify отсутствуют, class TickTock { String state; // содержит сведения о состоянии часов synchronized void tick(boolean running) { if(!running) { // остановить часы state = "ticked"; return; } System.out.print("Tick "); state = "ticked"; // установить текущее состояние после такта "тик" } synchronized void tock(boolean running) { if(!running) { // остановить часы state = "tocked"; return; } System.out.println("Tock") ; state = "tocked"; // установить текущее состояние после такта "так" } }

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

Это происходит потому, что методы tick и tock не взаимодействуют друг с другом. Приостановка, возобновление и остановка потоков

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

Механизмы приостановки, возобновление и остановки потоков менялись в разных версиях Java. До появления версии Java 2 для этих целей применялись методы suspend , resume и stop , определенные в классе Thread. Ниже приведены общие формы их объявления. final void resume final void suspend final void stop

На первый взгляд кажется, что упомянутые выше методы удобны для управления потоками, но пользоваться ими все же не рекомендуется по следующим причинам. При выполнении метода suspend иногда возникают серьезные осложнения, приводящие к взаимоблокировке. Метод resume сам по себе безопасен, но применяется только в сочетании с методом suspend . Что же касается метода stop из класса Thread, то и он не рекомендуется к применению, начиная с версии Java 2, поскольку может вызывать порой серьезные осложнения в работе многопоточных программ.

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

Следующий пример программы демонстрирует один из способов реализации собственных версий методов suspend , resume и stop . // Приостановка, возобновление и остановка потока. class MyThread implements Runnable { Thread thrd; // Если эта переменная принимает логическое значение // true, исполнение потока приостанавливается. volatile boolean suspended; // Если эта переменная принимает логическое значение // true, исполнение потока прекращается. volatile boolean stopped; MyThread(String name) { thrd = new Thread(this, name); suspended = false; stopped = false; thrd.start; } // Точка входа в поток public void run { System.out.println(thrd.getName + " starting."); try { for(int i = 1; i < 1000; i++) { System.out.print(i + " "); if((i %10)==0) { System.out.println ; Thread.sleep(250) ; } // Для проверки условий приостановки и остановки потока // используется следужхций синхронизированный блок. synchronized(this) { while(suspended) { wait; } if(stopped) break; } } } catch (InterruptedException exc) { System.out.println(thrd.getName + " interrupted."); } System.out.println(thrd.getName + " exiting."); } // остановить поток synchronized void mystopO { stopped = true; // Следующие операторы обеспечивают полную // остановку приостановленного потока, suspended = false; notify; } // приостановить поток synchronized void mysuspend { suspended = true; } // возобновить поток synchronized void myresume { suspended = false; notify; } } class Suspend { public static void main(String args[]) { MyThread obi = new MyThread("My Thread"); try { Thread.sleep(1000); // позволить потоку оЫ начать исполнение obi.mysuspend; System.out.println("Suspending thread."); Thread.sleep(1000); obi.myresume; System.out.println("Resuming thread."); Thread.sleep(1000); obi.mysuspend; System.out.println("Suspending thread."); Thread.sleep(1000); obi.myresume; System.out.println("Resuming thread.") ; Thread.sleep(1000); obi.mysuspend ; System.out.println("Stopping thread."); obi.mystop; } catch (InterruptedException e) { System.out.println("Main thread Interrupted"); } // ожидать завершения потока try { obi.thrd.join ; } catch (InterruptedException e) { System.out.println("Main thread Interrupted"); } System.out.println("Main thread exiting."); } }

Ниже приведен результат выполнения данной программы. My Thread starting. 123456789 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 Suspending thread. Resuming thread. 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 Suspending thread. Resuming thread. 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 Stopping thread. My Thread exiting. Main thread exiting.

Эта программа работает следующим образом. В классе потока 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 присутствует хотя бы один поток, называемый основным. Этот поток получает управление автоматически при запуске программы на выполнение. В этом проекте будет продемонстрировано, что основным потоком можно управлять таким образом же, как и любым другим.

Последовательность действий

Создайте файл UseMain.java.

Для доступа к основному потоку нужно получить ссылающийся на него объект типа Thread. Для этого следует вызвать метод currentThread , являющийся статическим членом класса Thread. Ниже приведено объявление этого метода. static Thread currentThread Метод currentThread возвращает ссылку на тот поток, из которого он вызывается. Так, если вызвать метод currentThread из основного потока, можно получить ссылку на этот поток. А имея ссылку на основной поток, можно управлять им.

Введите в файл UseMain. j ava приведенный ниже исходный код программы. В процессе ее выполнения сначала извлекается ссылка на основной поток, затем определяется и устанавливается имя и приоритет потока. /* Пример для опробования 11.2. Управление основным потоком. */ class UseMain { public static void main(String args[]) { Thread thrd; // получить основной поток thrd = Thread.currentThread; // отобразить имя основного потока System.out.println("Main thread is called: " + thrd.getName); // отобразить приоритет основного потока System.out.println("Priority: " + thrd.getPriority); System.out.println; // установить имя и приоритет основного потока System.out.println("Setting name and priority.\n"); thrd.setName("Thread #1"); thrd.setPriority(Thread.NORM_PRI0RITY+3); System.out.println("Main thread is now called: " + thrd.getName); System.out.println("Priority is now: " + thrd.getPriority); } }

Ниже приведен результат выполнения данной программы. Main thread is called: main Priority: 5 Setting name and priority. Main thread is now called: Thread #1 Priority is now: 8

Выполняя операции над основным потоком, необходимо соблюдать осторожность. Так, если добавить в конце метода main приведенный ниже код, программа никогда не завершится, потому что будет ожидать завершения основного потока!try { thrd.join; } catch(InterruptedException exc) { System.out.println("Interrupted"); } Упражнение для самопроверки по материалу главы 11

Каким образом имеющиеся в Java средства многопоточного программирования позволяют писать более эффективные программы?

Для поддержки многопоточного программирования в Java предусмотрен класс и интерфейс .

В каких случаях следует отдать предпочтение расширению класса Thread над реализацией интерфейса Runnable?

Покажите, как с помощью метода j oin можно организовать ожидание завершения потокового объекта MyThrd.

Покажите, как установить приоритет потока MyThrd на три уровня выше нормального приоритета.

Что произойдет, если в объявлении метода указать ключевое слово synchronized?

Методы wait и notify служат для __ .

Внесите в класс TickTock изменения для организации настоящего отчета времени. Первую половину секунды должен занимать вывод на экран слова "Tick", а вторую — вывод слова "Tock". Таким образом, сообщение "Tick-Tock" должно соответствовать одной секунде отсчитываемого времени. (Время переключения контекстов можно не учитывать.)

Почему в новых программах на Java не следует применять методы suspend, resume и stop?

С помощью какого метода из класса Thread можно получить имя потока?

Какое значение возвращает метод isAlive ?

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