How to solve Java instruction reordering in multi-threaded environment

1. Preface

Instruction rearrangement will help improve the execution efficiency of the program in a single-threaded environment and will not have a negative impact on the program; in a multi-threaded environment, instruction rearrangement will bring surprises to the program. Unexpected errors.

2. Problem recovery

(1) Associated variables

The following is an example that can fully recover the rearrangement of instructions.

public class D {
    static Integer a;
    static Boolean flag;
    
    public static void writer() {
        a = 1;
        flag = true;
    }
    
    public static void reader() {
        if (flag != null && flag) {
            System.out.println(a);
            a = 0;
            flag = false;
        }
    }
}

1. Result prediction

reader method only prints the variable a to the console when the flag variable is true value. The

writer method first performs the assignment operation of variable a, and then performs the assignment operation of variable flag.

If you follow the above analysis logic, then the results printed by the console must be all 1.

2. Instruction rearrangement

If the code does not have instruction rearrangement, then when the flag variable is true, the variable a must be 1.

In the above code, there are instruction rearrangements in both method classes regarding variables a and variables flag.

public static void writer() {
    a = 1;
    flag = true;
}

By observing the log output, we found that there are a large number of 0 outputs.

When the instruction rearrangement occurs inside the writer method, the flag variable completes the assignment first. At this time, if the current thread is interrupted, other threads are calling reader method, detects that the flag variable is true, then prints the value of the variable a. At this time, there are results in the console that exceed the expected value.

(2) New creates an object

When using the keyword new to create an object, because it is a non-atomic operation, there is instruction rearrangement. Instruction rearrangement will bring negative effects in a multi-threaded environment. Influence.

public class Singleton {
    private static UserModel instance;
    
    public static UserModel getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new UserModel(2, "B");
                }
            }
        }
        return instance;
    }
}

@Data
@AllArgsConstructor
class UserModel {
    private Integer userId;
    private String userName;
}

1. Analysis and creation process

• Use the keyword new to create an object, which is roughly divided into the following processes:

• Create a reference address in the stack space

• Use the class file as a template to allocate memory in the heap space object

• Initialize member variables

• Use the constructor to initialize

• Assign the reference value to the left storage variable

2. Analysis of the reordering process

For the above example, assume that the first thread enters the synchronized code block and starts to create an object. Due to the existence of reordering, the normal object creation process is disrupted, and it may appear that after the reference address is created in the stack space, The reference value is assigned to the left storage variable, and then an interrupt occurs due to the exhaustion of the CPU scheduling time slice.

After the subsequent thread detects that the instance variable is not empty, it will be used directly. Because singleton objects are not instantiated, using them directly will bring unexpected results.

3. Respond to instruction rearrangement

(1) AtomicReference atomic class

Use the atomic class to encapsulate a set of associated variables into an object, taking advantage of the characteristics of atomic operations , effectively avoiding the problem of command rearrangement.

@Data
@NoArgsConstructor
@AllArgsConstructor
public class ValueModel {
    private Integer value;
    private Boolean flag;
}

The atomic class should be the preferred solution for reordering instructions in a multi-threaded environment. It is not only easy to understand, but also the non-heavyweight mutex used between threads is relatively efficient.

public class E {
    private static final AtomicReference<ValueModel> ar = new AtomicReference<>(new ValueModel());
    
    public static void writer() {
        ar.set(new ValueModel(1, true));
    }
    
    public static void reader() {
        ValueModel valueModel = ar.get();
        if (valueModel.getFlag() != null && valueModel.getFlag()) {
            System.out.println(valueModel.getValue());
            ar.set(new ValueModel(0, false));
        }
    }
}

When a group of associated variables undergoes instruction rearrangement, using the atomic operation class is a better solution.

(2) volatile keyword

public class Singleton {
    private volatile static UserModel instance;
    
    public static UserModel getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new UserModel(2, "B");
                }
            }
        }
        return instance;
    }
}

@Data
@AllArgsConstructor
class UserModel {
    private Integer userId;
    private String userName;
}

4. Understanding of instruction rearrangement

1. Instruction rearrangement is widespread

Instruction reordering Arrangement is not limited to Java programs. In fact, various compilers have instruction rearrangement operations, ranging from software to CPU hardware. Instruction rearrangement is a performance optimization for single-threaded programs. It should be clear that instruction rearrangement will not change the expected results of sequential program execution in a single-threaded environment.

2. Instruction rearrangement in multi-threaded environment

The above discussed instruction rearrangement in two typical multi-threaded environments, analyzed its negative impacts, and provided countermeasures respectively.

• For associated variables, first encapsulate them into an object, and then use atomic classes to operate

• For new objects, use the volatile keyword to modify the target The object can

3. Synchronized locks have nothing to do with reordering

Synchronized locks ensure that threads access specific code blocks in an orderly manner through mutual exclusion locks. The code inside the code block is normally reordered according to the strategy implemented by the compiler.

Although synchronized locks can avoid the adverse effects of reordering in a multi-threaded environment, the thread overhead caused by mutex locks is relatively large and is not recommended.

Non-atomic operations in synchronized blocks may still cause instruction rearrangement

The above is the detailed content of How to solve Java instruction reordering in multi-threaded environment. For more information, please follow other related articles on the PHP Chinese website!