是！ JAVA中的原子操作

Question

if (!var) {...}

Does the above get expended into something like

• load value of var into register R
• set R = !R

Or its atomic where there is only a single operation

• load value of !var into register R

Answer 1

There is no bytecode level operation corresponding to logical not. It will typically get compiled as a branch, though the compiler can sometimes optimize that away.

For example, if you write code like b = !a , it would typically get compiled into something along the lines of

iload_0 ; load a
ifeq Lelse
iconst_0
goto Lend

Lelse:
iconst_1

Lend:
istore_1 ; store into B

However in the special case of if (!var) that you mentioned, this is not necessary. This is because the if instructions have variants for both regular and reversed conditions, ie instead of actually negating var , the compiler would just use the ifne instruction instead of the usual ifeq .

Edit: The above is how the code is compiled into bytecode. As far as synchronization goes, it is atomic for practical purposes. Since the code is purely local, there is ordinarily no way to observe side effects or for the calculation to interfere with other threads. Note that even if you load an unsynchronized field, the value becomes an intermediate value (ie a "register") and operations occur on that value, which is not shared among threads. No operation occurs directly on a field other than reads and writes.

That being said, since the code involves multiple bytecode instructions, you could stop a debugger in the middle of it. In that case, you could observe the intermediate state, although it would still have no effect on other threads.

Answer 2

No. It can't be.

Consider the following two scenarios:

Thread 1                Thread 2
--------                --------
Load A to register      ...
...                     Modify A
Invert register         ...

vs.

Thread 1                Thread 2
--------                --------
Atomically load !A      ...
    to register
...                     Modify A

The end result is the same -- in both cases, the register contains a value different from !A . The "atomic" nature of the load-inverted operation had absolutely no effect on the outcome.

If this seems like it could pose a problem, you probably need locking. Consider synchronizing on A , or on the container that it lives in.