Shulou(Shulou.com)05/31 Report--

This article analyzes "how to analyze double-checked locking in Java". The content is detailed and easy to understand. Friends who are interested in "how to analyze double check locking in Java language" can follow the editor's train of thought to read it slowly and deeply. I hope it will be helpful to everyone after reading. Let's follow the editor to learn more about "how to analyze double-checked locking in Java".

1. Double check locking

In program development, it is sometimes necessary to postpone some expensive object initialization operations and initialize them only when these objects are used, so double-check locking can be used to delay object initialization operations. Double check locking is a software design pattern designed to reduce competition and synchronization overhead in concurrent systems. on the basis of the ordinary singleton pattern, we first judge whether the object has been initialized, and then decide whether to lock it or not. Although double-checked locking solves the problems of error-prone and thread unsafe in common singleton mode in multithreaded environment, there are still some hidden dangers. Taking the source code of JAVA language as an example, this paper analyzes the causes and repair methods of double check locking defects.

2. The harm of double check locking

Double check locking has no effect in single-threaded environment, in multithreaded environment, because threads can switch and execute each other at any time, in the case of instruction rearrangement, the object is not fully instantiated, which leads to program call error.

3. Sample code

The example is from Samate Juliet Test Suite for Java v1.3 (https://samate.nist.gov/SARD/testsuite.php), source file name: CWE609_Double_Checked_Locking__Servlet_01.java.

3.1 defect code

The above code line 23-38 lines, the program first determines whether stringBad is null, if not, it directly returns the String object, so as to avoid the resources required to enter the synchronized block. When stringBad is null, use the synchronized keyword to avoid creating String objects multiple times in a multithreaded environment. Errors can still occur in the above code when the code is actually running.

For line 33, the creation of the stringBad object and the assignment are performed in two steps. However, JVM does not guarantee the sequence of these two operations. When instructions are reordered, JVM assigns values to the memory address before initializing the stringBad object. If there are two threads at this time, both threads enter line 27 at the same time. Thread 1 first enters the synchronized block, and because stringBad is null, it executes line 33. When JVM reorders instructions, JVM allocates blank memory for the instance and assigns values to stringBad, but the stringBad object is not instantiated yet, and thread 1 leaves the synchronized block. When thread 2 enters the synchronized block, since stringBad is not null at this time, it directly returns the uninstantiated object (only the memory address value, the object is not actually initialized). When subsequent thread 2 calls the program to operate on the stringBad object, the object is not initialized at this time, and an error occurs.

Using the 360 Code Guardian to detect the above sample code, you can detect a "double check lock" defect with a display level of medium. A defect is reported on line 27 of the code, as shown in figure 1:

Figure 1: detection example of "double check lock"

3.2 fix the code

In the above fix code, the singleton variable stringBad is modified with the volatile keyword in line 23. Volatile is used as an instruction keyword to ensure that instructions are not omitted due to compiler optimization and require direct reading each time. Due to compiler optimization, the code may actually be executed in a different order than we wrote. The compiler only ensures that the execution result of the program is the same as the source code, but does not guarantee that the order of the actual instructions is the same as that of the source code, and there is no error in the single-threaded environment. However, once the multithreaded environment is introduced, this disorder may lead to serious problems. The volatile keyword can solve this problem semantically, and it is worth noting that volatile's prohibition instruction reordering optimization function was not implemented until after Java 1.5, so versions prior to 1.5 are still unsafe, even with the volatile keyword.

Using 360 Code Guardian to detect the repaired code, you can see that there is no "double-checked locking" defect. Figure 2:

Figure 2: test results after repair 4. How to avoid double check locking

To avoid double-checked locking, you need to pay attention to the following:

(1) use the volatile keyword to avoid instruction reordering, but this solution requires JDK5 or later, because the new JSR-133 memory model specification is used from JDK5, which enhances the semantics of volatile.

(2) the solution based on class initialization.

JVM performs class initialization during the initialization phase of the class (that is, after the Class is loaded and before it is used by the thread). During class initialization, JVM acquires a lock. This lock can synchronize the initialization of the same class by multiple threads.

On how to use Java language analysis of double-checked locking is shared here, I hope that the above content can make you improve. If you want to learn more knowledge, please pay more attention to the editor's updates. Thank you for following the website!

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.