В многопоточном программировании Java часто встречается волатильное. Иногда это ключевое слово часто путают с синхронизированной или блокировкой. Конкретный анализ заключается в следующем:
В многопоточной среде будет проблема видимости переменных элементов: каждый поток в Java имеет пространство памяти стека потоков, которая сохраняет информацию переменной потока при запуске. Когда поток обращается к определенному значению переменной, он сначала найдет память кучи объекта или конкретное содержание стека (нативное тип данных) на основе адреса переменной, а затем сохранит копию того же значения в стеке потока этого потока. Затем все операции на этой переменной не имеют ничего общего с содержанием переменной в стеке до выхода поток. Он работает на копии в стеке потоков. После завершения операции результат операции будет записан в основную память. Если есть два потока A и B, а коллеги управляют определенной переменной x; A добавляет от 1 до x, тогда копия, полученная B, может быть результатом x плюс 1 или x; Чтобы гарантировать, что последняя переменная данных в памяти необходима для добавления летучих ключевых слов, поэтому каждый раз, когда вы работаете на x, вы проверяете, является ли значение переменной в стеке потоков таким же, как и значение переменной в памяти, и если она отличается, оно будет загружено снова.
например:
Открытый класс Threadsee {// Поток T1 будет выполнять соответствующие операции на основе значения флага, а основной поток изменит значение T1 public static void main (string [] args) бросает прерывания {threadTest th = new ThreadTest (); Потока T1 = новый поток (TH); t1.start (); Thread.sleep (1000); th.changeflag (); Thread.sleep (2000); System.out.println (th.getflag ()); }} class Threadsest реализует runnable {// Когда поток обращается к переменной, он загрузит ее в соответствующий стек потоков. Каждая операция, она должна получить последние данные в Permory Private Elatile Boolean Stopflag; @Override public void run () {int i = 0; while (! Stopflag) {i ++; System.out.println ("=="+Thread.currentThread (). GetName ()); } System.out.println ("Findive:"+i); } public void изменение flag () {this.stopflag = true; System.out.println (Thread.currentThread (). GetName ()+"*********"); } public boolean getflag () {return stopflag; }} Если вышеупомянутый код будет удален, он будет продолжать выполняться в мертвой петле.
Но нестабильный не может гарантировать безопасную синхронизацию потока
например:
Открытый класс Threadsave реализует runnable {static threadsave sync = new Threadsave (); Статический летучий int j = 0; // lock lock = new Reentrantlock (); public void inscane () {// lock.lock (); для (int i = 0; i <10000000; i ++) {j ++; } // lock.unlock (); } @Override public void run () {insCane (); } public static void main (string [] args) бросает прерывание {thread t1 = new Thread (sync); Потока T2 = новый поток (синхронизация); t1.start (); t2.start (); t1.join (); t2.join (); System.out.println (j); }} Результат выполнения в соответствии с вышеуказанным кодом, как ожидается, не составит 20000000,
Поскольку для переменных, модифицированных летучими, виртуальная машина JVM гарантирует, что значение, загруженное из основной памяти в потоку рабочей памяти, является последним.
Например, если поток 1 и поток 2 выполняют стек потоков и операции считывания и загрузки основной памяти, и обнаружите, что значение счета в основной памяти составляет 5, то последнее значение будет загружено. После изменения количества кучей потока 1 он будет записан в основную память, а переменная счета в основной памяти станет 6;
Поскольку поток 2 уже выполнил операции чтения и загрузки, после выполнения операции значение переменной основной памяти также будет обновлено до 6;
Это приводит к тому, что параллелизм возникает после того, как два потока изменяются с помощью летучивого ключевого слова во времени.
В итоге:
volatile только гарантирует, что поток выполняет действие, которое проверяет, является ли значение переменной текущего стека потоков таким же, как и значение данных в основной памяти, вот и все. Lock или Synchronized гарантирует, что только один поток входит в метод в определенный момент, что обеспечивает безопасность его потока.
Поэтому, если несколько потоков изменяют летучую переменную, то нет никакого реального логического значения. Если поток изменяет значение переменной других потоков, которые зависят от изменения, это будет полезно в настоящее время.
Выше приведено в этой статье, я надеюсь, что это будет полезно для каждого обучения.