Программирование на Java
Шрифт:
public void run {
synchronized (shared) {
shared.process;
}
}
Теперь результат будет строго упорядочен:
Thread-0 0
Thread-0 1
Thread-0 2
Thread-1 0
Thread-1 1
Thread-1 2
Thread-2 0
Thread-2 1
Thread-2 2
Synchronized -методы работают аналогичным образом. Прежде, чем начать выполнять их, поток пытается заблокировать объект, у которого вызывается метод. После выполнения блокировка
Также допустимы методы static synchronized. При их вызове блокировка устанавливается на объект класса Class, отвечающего за тип, у которого вызывается этот метод.
При работе с блокировками всегда надо помнить о возможности появления deadlock – взаимных блокировок, которые приводят к зависанию программы. Если один поток заблокировал один ресурс и пытается заблокировать второй, а другой поток заблокировал второй и пытается заблокировать первый, то такие потоки уже никогда не выйдут из состояния ожидания.
Рассмотрим простейший пример:
public class DeadlockDemo {
// Два объекта-ресурса
public final static Object one=new Object, two=new Object;
public static void main(String s[]) {
// Создаем два потока, которые будут
// конкурировать за доступ к объектам
// one и two
Thread t1 = new Thread {
public void run {
// Блокировка первого объекта
synchronized(one) {
Thread.yield;
// Блокировка второго объекта
synchronized (two) {
System.out.println("Success!");
}
}
}
};
Thread t2 = new Thread {
public void run {
// Блокировка второго объекта
synchronized(two) {
Thread.yield;
// Блокировка первого объекта
synchronized (one) {
System.out.println("Success!");
}
}
}
};
// Запускаем потоки t1.start;
t2.start;
}
}
Пример 12.4.
Если запустить такую программу, то она никогда не закончит свою работу. Обратите внимание на вызовы метода yield в каждом потоке. Они гарантируют, что когда один поток выполнил первую блокировку и переходит к следующей, второй поток находится в таком же состоянии. Очевидно, что в результате оба потока "замрут", не смогут продолжить свое выполнение. Первый поток будет ждать освобождения второго объекта, и наоборот. Именно такая ситуация называется "мертвой блокировкой", или deadlock. Если один из потоков успел бы заблокировать оба объекта, то программа успешно бы выполнилась до конца. Однако многопоточная архитектура не дает никаких гарантий, как именно потоки будут выполняться друг относительно друга. Задержки (которые в примере моделируются вызовами yield ) могут возникать из логики программы (необходимость произвести вычисления), действий пользователя (не сразу нажал кнопку "ОК"), занятости ОС (из-за нехватки физической оперативной памяти пришлось воспользоваться виртуальной), значений приоритетов потоков и так далее.
В Java нет никаких средств распознавания или предотвращения ситуаций deadlock. Также нет способа перед вызовом синхронизированного
Опасность возникновения взаимных блокировок заставляет с особенным вниманием относиться к работе с потоками. Например, важно помнить, что если у объекта потока был вызван метод sleep(..), то такой поток будет бездействовать определенное время, но при этом все заблокированные им объекты будут оставаться недоступными для блокировок со стороны других потоков, а это потенциальный deadlock. Такие ситуации крайне сложно выявить путем тестирования и отладки, поэтому вопросам синхронизации надо уделять много времени на этапе проектирования.
Методы wait, notify, notifyAll класса Object
Наконец, перейдем к рассмотрению трех методов класса Object, завершая описание механизмов поддержки многопоточности в Java.
Каждый объект в Java имеет не только блокировку для synchronized блоков и методов, но и так называемый wait-set, набор потоков исполнения. Любой поток может вызвать метод wait любого объекта и таким образом попасть в его wait-set. При этом выполнение такого потока приостанавливается до тех пор, пока другой поток не вызовет у этого же объекта метод notifyAll, который пробуждает все потоки из wait-set. Метод notify пробуждает один случайно выбранный поток из данного набора.
Однако применение этих методов связано с одним важным ограничением. Любой из них может быть вызван потоком у объекта только после установления блокировки на этот объект. То есть либо внутри synchronized -блока с ссылкой на этот объект в качестве аргумента, либо обращения к методам должны быть в синхронизированных методах класса самого объекта. Рассмотрим пример:
public class WaitThread implements Runnable {
private Object shared;
public WaitThread(Object o) {
shared=o;
}
public void run {
synchronized (shared) {
try {
shared.wait;
}
catch (InterruptedException e) {
}
System.out.println("after wait");
}
}
public static void main(String s[]) {
Object o = new Object;
WaitThread w = new WaitThread(o);
new Thread(w).start;
try {
Thread.sleep(100);
}
catch (InterruptedException e) {
}
System.out.println("before notify");
synchronized (o) {
o.notifyAll;
}
}
}
Результатом программы будет:
before notify
after wait
Обратите внимание, что метод wait, как и sleep, требует обработки InterruptedException, то есть его выполнение также можно прервать методом interrupt.
В заключение рассмотрим более сложный пример для трех потоков:
public class ThreadTest implements Runnable {