(zz)What does volatile do?
volatile
and synchronized
have on a method. volatile
is a field modifier, while synchronized
modifies code blocks and methods. So we can specify three variations of a simple accessor using those two keywords: int i1; int geti1() {return i1;}
volatile int i2; int geti2() {return i2;}
int i3; synchronized int geti3() {return i3;}
geti1()
accesses the value currently stored in i1
in the current thread. Threads can have local copies of variables, and the data does not have to be the same as the data held in other threads. In particular, another thread may have updated i1
in it's thread, but the value in the current thread could be different from that updated value. In fact Java has the idea of a "main" memory, and this is the memory that holds the current "correct" value for variables. Threads can have their own copy of data for variables, and the thread copy can be different from the "main" memory. So in fact, it is possible for the "main" memory to have a value of 1 for i1
, for thread1 to have a value of 2 for i1
and for thread2 to have a value of 3 for i1
if thread1 and thread2 have both updated i1
but those updated value has not yet been propagated to "main" memory or other threads. On the other hand,
geti2()
effectively accesses the value of i2
from "main" memory. A volatile
variable is not allowed to have a local copy of a variable that is different from the value currently held in "main" memory. Effectively, a variable declared volatile
must have it's data synchronized across all threads, so that whenever you access or update the variable in any thread, all other threads immediately see the same value. Of course, it is likely that volatile
variables have a higher access and update overhead than "plain" variables, since the reason threads can have their own copy of data is for better efficiency. Well if
volatile
already synchronizes data across threads, what is synchronized
for? Well there are two differences. Firstly synchronized
obtains and releases locks on monitors which can force only one thread at a time to execute a code block, if both threads use the same monitor (effectively the same object lock). That's the fairly well known aspect to synchronized
. But synchronized
also synchronizes memory. In fact synchronized
synchronizes the whole of thread memory with "main" memory. So executing geti3()
does the following: this
(assuming the monitor is unlocked, otherwise the thread waits until the monitor is unlocked). i3
, which may have just been reset from "main" memory). geti3()
we have no changes.) this
. So where
volatile
only synchronizes the value of one variable between thread memory and "main" memory, synchronized
synchronizes the value of all variables between thread memory and "main" memory, and locks and releases a monitor to boot. Clearly synchronized
is likely to have more overhead than volatile
.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
Is Eclipse IDE dying?In 2014 the Eclipse IDE is the leading development environment for Java with a market share of approximately 65%. but ac...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.