Comment résoudre la réorganisation des instructions Java dans un environnement multithread

1. Préface

Le réarrangement des instructions contribuera à améliorer l'efficacité d'exécution du programme dans un environnement monothread et n'aura pas d'impact négatif sur le programme dans un environnement multithread, le réarrangement des instructions entraînera des erreurs inattendues dans le programme ; .

2. Récupération du problème

(1) Variables associées

Ce qui suit est un exemple qui peut récupérer à 100% le réarrangement des 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. Prédiction du résultat

La méthode reader n'imprime la valeur de la variable a que lorsque la variable flag est vraie. . reader方法仅在flag变量为true时向控制台打印变量a的值。

writer方法先执行变量a的赋值操作，后执行变量flag的赋值操作。

如果按照上述分析逻辑，那么控制台打印的结果一定全为1。

2、指令重排

假如代码未发生指令重排，那么当flag变量为true时，变量a一定为1。

上述代码中关于变量a和变量flag在两个方法类均存在指令重排的情况。

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

通过观察日志输出，发现有大量的0输出。

当writer方法内部发生指令重排时，flag变量先完成赋值，此时假如当前线程发生中断，其它线程在调用reader方法，检测到flag变量为true，那么便打印变量a的值。此时控制台存在超出期望值的结果。

（二）new创建对象

使用关键字new创建对象时，因其非原子操作，故存在指令重排，指令重排在多线程环境下会带来负面影响。

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、解析创建过程

• 使用关键字new创建一个对象，大致分为一下过程：

• 在栈空间创建引用地址

• 以类文件为模版在堆空间对象分配内存

• 成员变量初始化

• 使用构造函数初始化

• 将引用值赋值给左侧存储变量

2、重排序过程分析

针对上述示例，假设第一个线程进入synchronized代码块，并开始创建对象，由于重排序存在，正常的创建对象过程被打乱，可能会出现在栈空间创建引用地址后，将引用值赋值给左侧存储变量，随后因CPU调度时间片耗尽而产生中断的情况。

后续线程在检测到instance

La méthode writer effectue d'abord l'opération d'affectation de la variable a, puis effectue l'opération d'affectation de la variable flag.

Si vous suivez la logique d'analyse ci-dessus, alors les résultats imprimés par la console doivent être tous 1.

2. Réarrangement des instructions

Si le code n'a pas de réarrangement des instructions, alors lorsque la variable flag est vraie, la variable a doit être 1.

Dans le code ci-dessus, il y a un réarrangement des instructions dans les deux classes de méthodes concernant la variable a et la variable flag.

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

En observant la sortie du journal, nous avons constaté qu'il existe un grand nombre de sorties 0.

Lorsque les instructions sont réorganisées à l'intérieur de la méthode writer, la variable flag est attribuée en premier. Si le thread en cours est interrompu à ce moment-là, d'autres threads appellent . reader</ code>, détecte que la variable <code>flag est vraie, puis imprime la valeur de la variable a. À l’heure actuelle, la console obtient des résultats qui dépassent les attentes.

(2) New crée des objets

Lors de l'utilisation du mot-clé new pour créer un objet, il y a un réarrangement des instructions en raison de son fonctionnement non atomique. Le réarrangement des instructions aura des effets négatifs dans un environnement multithread.

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));
        }
    }
}

1. Analysez le processus de création

Utilisez le mot-clé new pour créer un objet, qui est grossièrement divisé en les processus suivants :

• Créez une adresse de référence dans l'espace de pile

• Utilisez la classe fichier comme modèle pour allouer des objets dans l'espace du tas Mémoire

Initialisation de la variable membre

Utiliser l'initialisation du constructeur

Attribuer la valeur de référence à la variable de stockage de gauche

🎜🎜2. 🎜🎜Pour l'exemple ci-dessus, supposons que le premier thread entre dans le bloc de code synchronisé et commence à créer des objets. En raison de l'existence d'une réorganisation, le processus normal de création d'objets peut être perturbé après la création de l'adresse de référence dans l'espace de pile. , la valeur de référence est attribuée à la variable de stockage gauche, puis en raison du temps de planification du processeur, une interruption se produit en raison de l'épuisement de la puce. 🎜🎜Lorsque le thread suivant détecte que la variable instance n'est pas vide, elle sera utilisée directement. Étant donné que les objets singleton ne sont pas instanciés, leur utilisation directe entraînera des résultats inattendus. 🎜🎜3. Faire face au réarrangement des instructions🎜🎜 (1) Classe atomique AtomicReference🎜🎜Utilisez la classe atomique pour encapsuler un ensemble de variables liées dans un objet et utilisez les caractéristiques des opérations atomiques pour éviter efficacement le problème du réarrangement des instructions. 🎜

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;
}

🎜La classe atomique devrait être le premier choix pour résoudre le problème du réarrangement des instructions dans un environnement multithread. Elle est non seulement facile à comprendre, mais le verrouillage mutex non lourd utilisé entre les threads est également relativement efficace. 🎜rrreee🎜🎜Lorsque les instructions sont réorganisées pour un groupe de variables liées, l'utilisation de la classe d'opération atomique est une meilleure solution. 🎜🎜🎜 (2) mot clé volatile 🎜rrreee🎜 4. Compréhension du réarrangement des instructions 🎜🎜1. Le réarrangement des instructions est répandu 🎜🎜Le réarrangement des instructions ne se limite pas aux programmes Java. En fait, divers compilateurs ont des opérations de réarrangement des instructions allant du logiciel au processeur. matériel. Le réarrangement des instructions est une optimisation des performances pour les programmes monothread. Il doit être clair que le réarrangement des instructions ne modifiera pas les résultats attendus de l'exécution séquentielle d'un programme dans un environnement monothread. 🎜🎜2. Réarrangement des instructions dans des environnements multithread🎜🎜Les réarrangements d'instructions ci-dessus dans deux environnements multithread typiques, ont analysé leurs impacts négatifs et ont fourni des contre-mesures respectivement. 🎜🎜🎜🎜Pour les variables associées, encapsulez-les d'abord dans un objet, puis utilisez une classe atomique pour les faire fonctionner🎜🎜🎜🎜Pour les nouveaux objets, utilisez le mot-clé volatile pour modifier l'objet cible🎜🎜🎜🎜3. rien à voir avec la réorganisation🎜 🎜Les verrous synchronisés utilisent des verrous mutex pour garantir que les threads accèdent à des blocs de code spécifiques de manière ordonnée. Le code à l'intérieur du bloc de code est normalement réorganisé selon la stratégie mise en œuvre par le compilateur. 🎜🎜Bien que les verrous synchronisés puissent éviter les effets néfastes de la réorganisation dans un environnement multithread, la surcharge de thread causée par les verrous mutex est relativement importante et n'est pas recommandée. 🎜🎜🎜Les opérations non atomiques dans les blocs synchronisés peuvent toujours provoquer un réarrangement des instructions🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!