Управление непостоянством (volatility)

Указания по использованию volatile-переменных


Автор Брайан Гётц, 19 июня 2007 года. Оригинал: Managing Volatility

Volatile-переменные в Java можно назвать «synchronized-лайт»; для их использования нужно меньше кода, чем для synchronized-блоков, часто они выполняются быстрее, но при этом могут делать лишь часть из того, что делают synchronized. В этой статье представлено несколько паттернов эффективного использования volatile — и несколько предупреждений о том, где их использовать не надо.

У локов (locks) есть две основные черты: взаимное исключение (mutual exclusion, mutex) и видимость. Взаимное исключение означает, что лок может быть захвачен только одной нитью в отдельный момент времени, и это свойство можно использовать для реализации протоколов управления доступом к общедоступным ресурсам, так что только одна нить будет их использовать в отдельный момент времени. Видимость — вопрос более тонкий, ее задача обеспечить, что изменения, сделанные в общедоступных ресурсах до освобождения замка будут видимы следующей нити, захватившей этот замок. Если бы синхронизация не гарантировала видимость, нити могли бы получать устаревшие или неверные значения общедоступных переменных, что привело бы к целому ряду серьезных проблем.

Volatile-переменные

Volatile-переменные обладают свойствами видимости, присущими synchronized, но лишены их атомарности. Это означает, что нити автоматически будут использовать самые актуальные значения volatile-переменных. Их можно использовать для нитебезопасности (thread safety, чаще переводится как потокобезопасности), но в очень ограниченном наборе случаев: тех, что не вводят связи между несколькими переменными или между текущими и будущими значениями переменной. Таким образом, одной volatile недостаточно для реализации счетчика, мьютекса или любого класса, чьи неизменные части связаны с несколькими переменными (например, «start <=end»).

Предпочесть volatile локам можно по одной из двух основных причин: простоте или масштабируемости. Некоторые языковые конструкции легче записать в виде программного кода, а в дальнейшем — прочесть и разобраться, когда они используют volatile-переменных вместо локов. Кроме того, в отличие от локов, они не могут заблокировать нить, и поэтому менее чреваты проблемами масштабируемости. В ситуациях, когда операций чтения гораздо больше, чем записи, volatile-переменные могут дать выигрыш в производительности по сравнению с локами.

Условия правильного использования volatile

Заменить локи на volatile можно в ограниченном числе обстоятельств. Для нитебезопасности необходимо, чтобы выполнялись оба критерия:

  1. То, что записывается в переменную, не зависит от ее текущего значения.
  2. Переменная не участвует в инвариантах с другими переменными.

Проще говоря, эти условия означают, что корректные значения, которые могут быть записаны в volatile-переменную, не зависят от любого другого состояния программы, включая текущее состояние переменной. Первое условие исключает использование volatile-переменных как нитебезопасных счетчиков. Хотя инкремент (x++) выглядит как одна операция, в действительности это целая последовательность операций чтения-изменения-записи, которая должна выполняться атомарно, чего volatile не обеспечивает. Корректная операция требовала бы, чтобы значение x оставалось неизменным в течение всей операции, чего нельзя добиться с помощью volatile. (Однако если вам удастся обеспечить, что значение будет записываться только из одной нити, первое условие можно опустить).

В большинстве ситуаций будет нарушено либо первое, либо второе условия, что делает volatile-переменные менее используемым подходом к достижению нитебезопасности, чем synchronized. В листинге 1 показан не-нитебезопасный класс с диапазоном чисел. Он содержит инвариант — нижняя граница всегда меньше или равна верхней.

@NotThreadSafe 
public class NumberRange {
    private int lower, upper;
 
    public int getLower() { return lower; }
    public int getUpper() { return upper; }
 
    public void setLower(int value) { 
        if (value > upper) 
            throw new IllegalArgumentException(...);
        lower = value;
    }
 
    public void setUpper(int value) { 
        if (value < lower) 
            throw new IllegalArgumentException(...);
        upper = value;
    }
}


Поскольку переменные состояния диапазона ограничены таким образом, будет недостаточным сделать поля lower и upper volatile, чтобы обеспечить нитебезопасность класса; по-прежнему будет нужна синхронизация. Иначе рано или поздно не повезет и две нити, выполнившие setLower() и setUpper() с неподходящими значениями могут привести диапазон в противоречивое состояние.

Например, если начальное значение (0, 5), нить A вызывает setLower(4), и в то же время нить B вызывает setUpper(3), эти перемежающиеся операции приведут к ошибке, хотя обе пройдут проверку, которая должна защищать инвариант. В итоге диапазон будет (4, 3) — неверные значения. Нам нужно сделать setLower() и setUpper() атомарными по отношению к другим операциям над диапазоном — и присвоение полям volatile этого не сделает.

Соображения производительности

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

Чрезвычайно трудно сделать точные всеобъемлющие заявления вида «X всегда быстрее, чем Y,» особенно когда речь идет о внутренних операциях виртуальной машины Java. (Например, JVM может полностью снять блокировку в некоторых ситуациях, что затрудняет абстрактное обсуждение затрат на volatile по отношению к синхронизации). Тем не менее, на большинстве современных процессорных архитектур затраты на чтение volatile мало отличаются от затрат на чтение обычных переменных. Затраты на запись volatile значительно больше, чем на запись обычных переменных, из-за ограждения памяти, необходимого для обеспечения видимости, но в целом дешевле, чем установка локов.

Паттерны для правильного использования volatile
Многие эксперты по параллелизму склонны избегать использования volatile-переменных вообще, потому что их труднее использовать правильно, чем локи. Однако существуют некоторые четко определенные паттерны, которые, если следовать им внимательно, могут безопасно использоваться в самых разных ситуациях.
Всегда учитывайте ограничения volatile — используйте только volatile, которые никак не зависят от всего остального в программе, и это должно не позволить вам залезть с этими паттернами на опасную территорию.
Паттерн №1: флаги состояния
Возможно, каноническое использование изменчивых переменных — это простые булевы флаги состояния, указывающие на то, что произошло важное одноразовое событие жизненного цикла, такое как завершение инициализации или запрос на завершение работы. Многие приложения включают конструкцию управления формы: «Пока мы не готовы выключиться, продолжаем работать», как показано в листинге 2:

volatile boolean shutdownRequested;
 
...
 
public void shutdown() { shutdownRequested = true; }
 
public void doWork() { 
    while (!shutdownRequested) { 
        // do stuff
    }
}


Вероятно, метод shutdown () будет вызываться откуда-то извне цикла — в другой нити — поэтому требуется синхронизация для обеспечения правильной видимости переменной shutdownRequested. (Он может быть вызван из слушателя JMX, слушателя действий в нити событий GUI, через RMI, через веб-службу и т. д.). Однако цикл с синхронизированными блоками будет гораздо громоздким, чем цикл с volatile-флагом состояния как в листинге 2. Поскольку volatile упрощает написание кода, а флаг состояния не зависит от какого-либо другого состояния программы, это пример хорошего использования volatile.

Для таких флагов статуса характерно то, что обычно существует только один переход состояния; флаг shutdownRequested переходит из false в true, а затем программа выключается. Этот паттерн можно расширить до флагов состояния, которые могут изменяться туда и обратно, но только если цикл перехода (от false до true to false) будет происходить без внешних вмешательств. В противном случае необходим какой-то атомарный механизм перехода, такой как атомарные переменные.

Паттерн № 2: одноразовая безопасная публикация

Ошибки видимости, которые возможны при отсутствии синхронизации, могут стать еще более сложным вопросом, когда происходит запись ссылок на объекты вместо примитивных значений. Без синхронизации можно увидеть актуальное значение для ссылки на объект, которое было записано другой нитью, и по-прежнему видеть устаревшие значения состояния этого объекта. (Эта угроза лежит в корне проблемы с печально известной блокировкой с двойной проверкой, где ссылка на объект считывается без синхронизации, и вы рискуете увидеть актуальную ссылку, но получить через нее частично сконструированный объект.)

Один из способов безопасной публикации объекта состоит в том, чтобы сделать ссылку на объект volatile. В листинге 3 показан пример, где во время запуска фоновый поток загружает некие данные из базы данных. Другой код, когда может попытаться использовать эти данные, проверяет, был ли он опубликован, прежде чем пытаться его использовать.

public class BackgroundFloobleLoader {
    public volatile Flooble theFlooble;
 
    public void initInBackground() {
        // делаем много всякого
        theFlooble = new Flooble();  // единственная запись в theFlooble
    }
}
 
public class SomeOtherClass {
    public void doWork() {
        while (true) { 
            // чё-то там делаем...
            // используем theFolooble, но только если она готова
            if (floobleLoader.theFlooble != null) 
                doSomething(floobleLoader.theFlooble);
        }
    }
}


Если бы ссылка на theFlooble не была volatile, код в doWork() рисковал бы увидеть частично сконструированный Flooble при попытке обратиться по theFlooble.

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

Паттерн № 3: независимые наблюдения

Другой простой пример безопасного применения volatile — ситуация, когда наблюдения периодически “публикуются” для использования в рамках программы. Например, есть датчик окружающей среды, который определяет текущую температуру. Фоновая нить может считывать показания этого датчика с периодом в несколько секунд и обновлять volatile-переменную, содержащую текущую температуру. Затем другие нити могут считывать эту переменную, зная, что значение в ней всегда самое актуальное.

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

public class UserManager {
    public volatile String lastUser;
 
    public boolean authenticate(String user, String password) {
        boolean valid = passwordIsValid(user, password);
        if (valid) {
            User u = new User();
            activeUsers.add(u);
            lastUser = user;
        }
        return valid;
    }
}


Этот паттерн расширяет предыдущий; значение публикуется для использования где-то еще в программе, но публикация не одноразовое событие, а серия независимых. Этот паттерн требует, чтобы опубликованное значение было фактически неизменным — что его состояние после публикации не менялось. Код, использующий значение, должен знать, что оно может в любой момент измениться.

Паттерн № 4: паттерн «volatile bean»

Паттерн “volatile bean” применим во фреймворках, использующих JavaBeans как “glorified structs”. В паттерне “volatile bean” JavaBean используется как контейнер для группы независимых свойств с геттерами и/или сеттерами. Обоснованием необходимости паттерна “volatile bean” является то, что многие фреймворки предоставляют контейнеры для изменяемых держателей данных (например, HttpSession), но объекты, помещенные в эти контейнеры, должны быть нитебезопасными.

В патттерне volatile bean все элементы данных JavaBean являются volatile, а геттеры и сеттеры должны быть тривиальными — они не должны содержать никакой логики, кроме получения или установки соответствующего свойства. Кроме того, для членов данных, которые являются объектными ссылками, упомянутые объекты должны быть эффективно неизменными. (Это запрещает наличие полей-ссылок на массивы, так как когда ссылка массива объявлена volatile, только эта ссылка, а не сами элементы, имеет свойство volatile.) Как и в любой volatile-переменной, не может быть никаких инвариантов или ограничений, связанных с свойствами JavaBeans. Пример JavaBean, написанного по паттерну “volatile bean”, показан в листинге 5:

@ThreadSafe
public class Person {
    private volatile String firstName;
    private volatile String lastName;
    private volatile int age;
 
    public String getFirstName() { return firstName; }
    public String getLastName() { return lastName; }
    public int getAge() { return age; }
 
    public void setFirstName(String firstName) { 
        this.firstName = firstName;
    }
 
    public void setLastName(String lastName) { 
        this.lastName = lastName;
    }
 
    public void setAge(int age) { 
        this.age = age;
    }
}


Более сложные volatile-паттерны

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

Более продвинутые паттерны использования volatile могут быть чрезвычайно хрупкими. Крайне важно, чтобы ваши предположения были тщательно задокументированы, а эти паттерны сильно инкапсулироваными, потому что даже мельчайшие изменения могут сломать ваш код! Кроме того, учитывая, что основной причиной для более сложных вариантов использования volatile является производительность, убедитесь, что у вас действительно есть выраженная потребность в предполагаемом усилении производительности, прежде чем применять их. Эти паттерны являются компромиссами, которые жертвуют читабельностью или легкостью поддержки ради возможного повышения производительности — если вам не требуется повышение производительности (или вы не можете доказать, что вам это нужно, с помощью строгой программы измерения), то это, вероятно, плохая сделка, потому что вы отказываетесь от чего-то ценного и получаете что-то меньшее взамен.

Паттерн № 5: дешевый лок чтения-записи

Сейчас вы должны уже хорошо понимать, что volatile слишком слаба для реализации счетчика. Поскольку ++ x по факту сокращение трех операций (чтение, добавление, хранение), при неудачном стечении обстоятельств вы потеряете обновленное значение, если несколько потоков попытаются одновременно увеличить volatile-счетчик.

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

@ThreadSafe
public class CheesyCounter {
    // Employs the cheap read-write lock trick
    // All mutative operations MUST be done with the 'this' lock held
    @GuardedBy("this") private volatile int value;
 
    public int getValue() { return value; }
 
    public synchronized int increment() {
        return value++;
    }
}


Причина, по которой этот метод называется «дешевым локом чтения-записи», заключается в том, что вы используете разные механизмы синхронизации для чтения и записи. Поскольку операции записи в этом случае нарушают первое условие использования volatile, вы не можете использовать volatile для безопасной реализации счетчика — вы должны использовать блокировку. Однако вы можете использовать volatile для обеспечения видимости текущего значения при чтении, поэтому вы используете блокировку для всех операций изменения и volatile для операций read-only. Если лок позволяет только одной нити за раз получать доступ к значению, volatile-чтения допускают более одного, поэтому, когда вы используете volatile для защиты чтения, вы получаете более высокий уровень обмена, чем если бы вы использовали блокировку для всего кода: и чтения, и записи. Однако имейте в виду хрупкость этого паттерна: с двумя конкурирующими механизмами синхронизации он может стать очень сложным, если вы выйдете за пределы самого базового приложения этого паттерна.

Резюме

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

Некорректность com.javarush.test.level17.lesson10.home04

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

Основы Параллелизма: взаимоблокировки и мониторы объектов (раздел 3) (перевод статьи)

Исходная статья: www.javacodegeeks.com/2015/09/concurrency-fundamentals-deadlocks-and-object-monitors.html
Автор: Martin Mois

Первые две части перевода здесь.

Содержание

1. Живучесть
 1.1 Взаимоблокировка
 1.2 Голодание
2. Мониторы объектов совместно с wait() и notify()
 2.1 Вложенные синхронизированные блоки совместно с wait() и notify()
 2.2 Условия в синхронизированных блоках
3. Проектирование для многонитевости
 3.1 Неизменяемый объект
 3.2 Проектирование API
 3.3 Локальное хранилище нити

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

3.1 Неизменный объект
Одним из правил проектирования, являющихся очень важным в данном контексте, является Неизменяемость. Если вы распределяете экземпляры объектов, например, между различными нитями, то должны уделить внимание тому, чтобы две нити не изменяли один и тот же объект одновременно. В подобных ситуациях легко управляться с немодифицируемыми объектами, поскольку вы не можете их изменить. Вы всегда должны создавать новый экземпляр, когда хотите изменить данные. Базовый класс java.lang.String — пример неизменяемого класса. Вы получаете новый экземпляр всякий раз, когда хотите изменить строку:

String str = "abc";

String substr = str.substring(1);


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

Далее приведён список правил, которые необходимо применять, чтобы сделать класс неизменяемым:
  • ,

Основы Параллелизма: взаимоблокировки и мониторы объектов (разделы 1, 2) (перевод статьи)

Исходная статья: www.javacodegeeks.com/2015/09/concurrency-fundamentals-deadlocks-and-object-monitors.html
Автор: Martin Mois

Эта статься — часть нашего курса Основы Параллелизма в Java.

В этом курсе вы погрузитесь в магию параллелизма. Вы познаете основы параллелизма и параллельного кода, познакомитесь с такими концепциями как атомарность, синхронизация нитебезопасность. Взгляните на него здесь!


Содержание

1. Живучесть
 1.1 Взаимоблокировка
 1.2 Голодание
2. Мониторы объектов совместно с wait() и notify()
 2.1 Вложенные синхронизированные блоки совместно с wait() и notify()
 2.2 Условия в синхронизированных блоках
3. Проектирование для многонитевости
 3.1 Неизменяемый объект
 3.2 Проектирование API
 3.3 Локальное хранилище нити

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

1.1 Взаимная блокировка
Термин взаимоблокировка хорошо известен разработчикам ПО и даже большинство обычных пользователей используют его время от времени, хотя и не всегда в правильном смысле. Строго говоря, этот термин означает, что каждая из двух (или больше) нитей ждут от другой нити, чтобы она освободила заблокированный ею ресурс, в то время как первая сам заблокировала ресурс, доступа к которому ждёт вторая:


Thread 1: locks resource A, waits for resource B

Thread 2: locks resource B, waits for resource A


Для лучшего понимания проблемы взглянем на следующий код:
  • ,

Тяжело заходит Synhronized? Делюсь решением.

Сто пудов я не оригинален. Большинство и без моего совета смотрят видео Головоча, но все же… Если Вам тяжело дается Synchronized, да и вообще Multithreading гляньте следующие лекции:

Multithreading #1
Multithreading #2
Multithreading #3

Мне очень помог момент когда Головач нарисовал два set'а, wait и blocked. Стола понятно кто кого ждет и зачем. Именно этот момент помог разложить концепцию Multithreading в голове.
  • ,

Синхронизация потоков, блокировка объекта и блокировка класса

March 8, 2013 Lokesh Gupta
Синхронизация относится к многопоточности. Синхронизированый блок кода может быть выполнен только одним потоком одновременно.

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

level16.lesson13.bonus02

Такая вот задачка, вроде все пункты выполнены, кто знает в чем дело? ):
Укажите на ошибки, если они есть :)


package com.javarush.test.level16.lesson13.bonus02;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

/* Клубок
1. Создай 5 различных своих нитей c отличным от Thread типом:
1.1. нить 1 должна бесконечно выполняться;
1.2. нить 2 должна выводить "InterruptedException" при возникновении исключения InterruptedException;
1.3. нить 3 должна каждые полсекунды выводить "Ура";
1.4. нить 4 должна реализовать интерфейс Message, при вызове метода showWarning нить должна останавливаться;
1.5. нить 5 должна читать с консоли цифры пока не введено слово "N", а потом вывести в консоль сумму введенных цифр.
2. В статическом блоке добавь свои нити в List<Thread> threads в перечисленном порядке.
3. Нити не должны стартовать автоматически.
*/

......
}