Java – what is the memory range to refresh or publish to various threads when using volatile and synchronized?

This problem only concerns memory visibility and does not occur before and after There are four ways in Java to ensure that memory changes in one thread are visible to another thread (Reference) http://gee.cs.oswego.edu/dl/cpj/jmm.html )

>The write thread releases the synchronization lock, and the read thread then obtains the same synchronization lock. > If a field is declared volatile, any value written to the file will be refreshed and made visible before the writer thread performs any further memory operations (that is, it will be refreshed immediately for the purpose at hand). > When a thread accesses an object's field for the first time, it will see the initial value of the field or the value written from some other thread. > When a thread terminates, all written variables are flushed to main memory

According to Java concurrency in practice, the Bible on these issues:

Volatile problem

Does this mean that the JVM actually tracks volatile variable reads and writes to know how to flush memory from a to B instead of a to C? So a writes to the variable, then C reads from the variable, and then B reads from the variable. The refresh is completed on the basis of each thread between a and B and between a and C, not B and C? Or does it imply that all cached memory is flushed, regardless of the thread? Did you just flush the volatile variable, or did you flush all the cached memory?

Synchronization problem

For synchronized keyword refresh, it means that only the updated memory inside the lock can be guaranteed to be published to other threads This means that in the following code, for two threads running method (), keeping the synchronized block will refresh staticvar2 to another thread, but not staticvar1. Is this correct?

In addition, in method2 (), if another thread is executing method (), it can cause a problem to occur before a problem occurs - a problem is encountered But the problem is visibility If thread a executes the method, then subsequent thread B executes method2 (), which is the value of staticvar2 published from a to B, even if the two threads are not synchronized through the same lock?

static int staticVar1,staticVar2;
void method() {
    staticVar1++;
    synchronized (lock) {
        staticVar2++;
    }
}
void method2() {
    synchronized (differentLock) {
        staticVar2++;
    }
}

Static problem

In my opinion, if staticvar1 is never updated to other threads, all static variables in any program need a volatile declaration or can only be accessed in synchronized blocks This may seem rather harsh, but is it correct? I'm sure I've seen a lot of asynchronous static variables in my time

in summary

>Will volatile reads and writes flush all memory to all threads, or only between two access threads? No matter which answer, is all memory flushed or only variables? > When exiting the synchronization block, or just the memory changed in the block, did you refresh the memory? If all memory is not flushed, do the locked objects synchronized by threads have to be the same to see this value (that is, does the locked object have any impact on memory visibility)? > Must all static variables accessed by two threads be synchronized?

Solution

There is no range limit on memory When you have a read or write barrier, it applies to all memory read / write

Where did I see the limitations of memory mapping When you create a memory mapping file, you must be careful how to make it available to another thread, because the new memory mapping may not be visible in another thread, which will immediately lead to a bus error (and JVM crash). This seems to be an operating system error, because the latest versions of Linux and windows do not seem to have this problem

Statixvar1 will always be refreshed when staticvar2 may be faster There is no guarantee when, but the order is guaranteed

Yes, the lock used is irrelevant to the first occurrence guarantee

All dirty memory is flushed on the write barrier, and all reads are in the same order on the read barrier Volatile is the write barrier when performing write operations and the read barrier when performing read operations

The thread changed all memory

Only when a thread modifies a variable Any number of threads can read static values without synchronization