Shulou(Shulou.com)06/02 Report--

This article mainly explains "what is the underlying implementation principle of Java concurrency mechanism". The content of the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what is the underlying implementation principle of Java concurrency mechanism"?

The underlying implementation principle of Java concurrency Mechanism

Terminology understanding

Cache line: the minimum operating unit of the cache.

Atomic operation: an uninterruptible operation or series of operations.

CAS (Compare and Swap), compare and set. Used to provide atomic operations at the hardware level. The CAS operation needs to enter two values, an old value (the value before the operation) and a new value. During the operation, compare whether the old value has changed, replace it with the new value if there is no change, and do not exchange if there is a change.

1. Volatile

Volatile is a lightweight synchronized that ensures variable visibility in multiprocessor development. That is, when one thread modifies a shared variable, another thread can read the modified value.

If a field is declared as the volatile,Java thread memory model, ensure that all threads see the same value of the variable.

Volatile has visibility, orderliness and no atomicity.

1.1 the implementation principle of volatile in CPU / / Java code is as follows: instance = new Sington (); / / instance is a volatile variable / / converted to assembly code as follows: 0x01a3deld: movb $0x0dl ox1104800 (% esi); 0x01a3de24: lock add1 $0x0, (% esp)

Shared variables decorated with volatile variables will have a second line of assembly code when writing. Looking at the IA-32 architecture software developer's manual, you will find that the Lock prefix instruction causes two things under multi-core processors:

Writes the data of the current processor cache row back to system memory.

This write-back operation invalidates data caching that memory address in other CPU.

In order to improve the processing speed, the processor does not communicate directly with the memory, but reads the data in the system memory to the internal cache (L1 and L2 or other) before operating, but does not know when it will be written to memory after the operation. If you write to a variable that declares volatile, JVM sends an instruction with a Lock prefix to the processor to write the data from the cache line of the variable back to system memory. However, even if you write back to memory, there will be problems performing calculations if the values cached by other processors are still old. Therefore, under multiprocessors, in order to ensure that the cache of each processor is consistent, the cache consistency protocol will be implemented. Each processor checks whether the value of its cache has expired by sniffing the data propagated on the bus. when the processor finds that the memory address of its cache line has been modified, it will set the cache line of the current processor to an invalid state. When the processor modifies the data, it re-reads the data from the system memory into the processor cache.

1.2 implementation principles of volatile

As can be seen from Section 1.1, the implementation rules of volatile are to achieve the above results. The two specific rules are:

The Lock prefix instruction causes the processor cache to write back to memory.

Writing back one processor cache to memory will invalidate the cache of other processors.

2. Synchronized

Synchronized has order, visibility and atomicity.

Synchronized is the basis for synchronization-every object in Java can be used as a lock, as shown in:

For normal synchronization methods, the lock is the current instance object.

For static synchronization methods, the lock is the current Class object.

For synchronous method blocks, locks are objects configured in synchronized parentheses.

2.1 Java object header (lock location of synchronized)

Synchronized locks are stored in the Java object header. To be exact, it is inside the Mark Word in the object's head.

If the object is a non-array type, the object header is stored with two word widths; if the object is an array type, the virtual machine stores the object header with three word widths. (when the Java object is an array, the object header must also have a piece of data to record the length of the array. Because there is no record of array size in Java array metadata)

In the head of the Java object:

Mark Word. A word width used to store the hashCode or lock information of an object.

Class Metadata Address. A word width, a pointer to store object type data.

Array Length. A word width that stores the length of the array (provided the object is an array).

The data of Mark Word will change with the change of lock flag bit.

2.2 upgrade and comparison of locks

Lock one has four middle states, from low to high: no lock state, partial lock state, lightweight lock state, heavy lock state. These states will be upgraded with competition, but locks can only be upgraded and not degraded.

2.2.1 bias lock

In most cases, there is no multi-thread competition, and most of the locks are acquired by the same thread many times. In order to reduce the cost of acquiring locks, biased locks are introduced.

A biased lock is a mechanism that waits for competition to release the lock, so when other threads try to compete for the biased lock, the thread that holds the biased lock releases the lock.

When a thread acquires a lock successfully, the lock-biased thread ID is stored in the Mark Word of the object header and in the lock record in the stack frame. Threads do not need to use CAS to lock and unlock synchronization blocks when entering and exiting later.

The thread holding the biased lock releases the lock only when other threads compete.

Revocation of biased locks requires waiting for the global security point. (there is no bytecode being executed at this point in time)

The above are the characteristics of bias lock.

Acquisition of biased lock

Check whether the thread ID of the current thread is stored in the Mark Word of the object header. Yes indicates that the thread has acquired the lock; if not, check whether the biased lock ID in Mark Word is set to 1.

If set to 1 (indicating that the current lock state is biased lock), use CAS to point the object header bias lock to the current thread.

If it is not set to 1 (indicating that the current lock state is not a biased lock), CAS contention locks are used

Revocation of bias lock

First, pause the thread holding the biased lock and judge whether the thread is alive or not. If the thread is not active, the Mark Word of the object is set to unlocked.

If the thread is still alive, the Mark Word that holds the lock record and the object header in the lock-biased stack will either be biased towards other threads or restored to an unlocked state, or mark that the object is not suitable as a biased lock, and finally wake up the paused thread.

Turn off the bias lock

Turn off delayed startup with the JVM parameter-XX:BiasedLockingStartupDelay=0.

Turn off the bias lock through the JVM parameter-XX:-UseBiasedLocking=false, and enter the lightweight lock state by default.

2.2.2 lightweight lock

Light weight lock

Before the thread executes the synchronization block, JVM creates a space to store the lock record in the stack frame of the current thread, and copies the Mark Word of the object header to the lock record.

The thread attempts to replace the Mark Word of the object header with a pointer to the lock record in the stack. If successful, the current thread acquires the lock.

If it fails, it indicates that other threads are competing for the lock, and the current thread attempts to use spin to acquire the lock.

Lightweight lock unlock

Use the atomic CAS operation to replace the Mark Word stored in the lock record in the current thread stack frame back to the object header.

If successful, there is no thread competing for the lock.

If it fails, it indicates that there is a competition for the current lock, and the lock will expand to a heavyweight lock. The lock state in Mark Word becomes a pointer to the heavyweight lock.

Because spin consumes CPU, to avoid useless spins (such as blocking the thread that acquired the lock), the lock will not be restored once it is upgraded to a heavyweight lock. When the lock is in a heavyweight lock state, other threads are blocked when they try to access it.

2.2.3 the advantages and disadvantages of locks compare the advantages and disadvantages of locks in scenarios where locking and unlocking do not require additional consumption, and there is only a nanosecond gap between locking and unlocking and executing asynchronous methods. If there is lock contention between threads, it will lead to additional consumption of lock revocation. Applies to scenarios where only one thread accesses the synchronous block. Lightweight lock contending threads do not block, which improves the response speed of the program. If threads that never get lock contention use spin, it consumes CPU pursuit response time. The execution speed of synchronous blocks is very fast. Heavy lock threads compete without spin and do not consume CPU. Threads are blocked and response time is slow. Pursue throughput. The execution speed of synchronous block is longer. 3. Atomic Operations 3.1 how does the processor implement atomic operations (1) use cache locks to maintain atomicity (2) use bus locks to maintain atomicity

The bus lock uses a LOCK # signal provided by the processor. When one processor outputs this signal on the bus, the requests of other processors will be blocked, so the processor can monopolize the shared memory. However, during the locking period, other processors can not operate the data of other memory addresses, so the bus locking overhead is high.

3.2 how to implement atomic operations in Java (1) using cyclic CAS to implement atomic operations

Thread-safe counter code implemented using CAS. The problem of implementing atomic operations in CAS:

ABA problem

CAS updates the new value according to whether the old value has changed, so in order to solve the ABA problem, you can add the version number A-> B-> A before the variable to become 1A-> 2B-> 3A.

The cycle length is expensive.

Only one atomic operation of a shared variable can be maintained

After jdk1.5, the AtomicReference class is provided to ensure atomicity between reference objects, and multiple variables can be placed in a single object for CAS operations.

(2) using locking mechanism to realize atomic operation.

JVM implements many kinds of locking mechanisms, such as bias lock, mutex lock, lightweight lock.

Thank you for your reading, the above is the content of "what is the underlying implementation principle of Java concurrency mechanism". After the study of this article, I believe you have a deeper understanding of what the underlying implementation principle of Java concurrency mechanism is, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.