Comment implémenter le modèle de mémoire et la réorganisation des instructions de la technologie sous-jacente de Java-javaDidacticiel-php.cn

Comment implémenter le modèle de mémoire et la réorganisation des instructions de la technologie sous-jacente de Java

王林

Libérer： 2023-11-08 12:25:01

original

1226 Les gens l'ont consulté

Comment implémenter le modèle de mémoire et la réorganisation des instructions de la technologie sous-jacente de Java

Comment implémenter le modèle de mémoire et la réorganisation des instructions dans la technologie sous-jacente Java

Aperçu :
Dans la technologie sous-jacente Java, le modèle de mémoire et la réorganisation des instructions sont deux concepts importants. Le modèle de mémoire contrôle la manière dont les variables partagées sont accessibles, tandis que la réorganisation des instructions affecte l'ordre dans lequel les instructions sont exécutées dans le programme. Cet article présentera les principes de base du modèle de mémoire Java et de la réorganisation des instructions, et donnera des exemples de code spécifiques.

Modèle de mémoire :
Java Memory Model (JMM) définit les règles de comportement lorsque plusieurs threads accèdent simultanément aux données partagées. En utilisant un modèle de mémoire, nous pouvons garantir la visibilité, l'atomicité et l'ordre des données sur plusieurs threads.

Les principaux concepts du modèle de mémoire Java sont :

Mémoire principale : une zone mémoire partagée par tous les threads, qui stocke les valeurs des variables partagées.
Mémoire de travail : une zone mémoire exclusive à chaque thread qui stocke une copie des variables partagées.

Les règles du modèle de mémoire Java sont les suivantes :

Toutes les opérations sur les variables partagées par les threads doivent être effectuées dans la mémoire de travail, plutôt que directement sur la mémoire principale.
Les threads ne peuvent pas accéder directement à la mémoire de travail des autres et la communication entre les threads doit être effectuée via la mémoire principale.

Exemple de code :

public class MemoryModelDemo {
    private static volatile boolean flag = false;

    public static void main(String[] args) {
        new Thread(() -> {
            while (!flag) {
                // do something
            }
            System.out.println("Thread 1: flag is true");
        }).start();

        new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true;
            System.out.println("Thread 2: flag is changed to true");
        }).start();
    }
}

Copier après la connexion

Dans l'exemple ci-dessus, nous implémentons la communication entre les threads via une variable partagée flag modifiée par le modificateur volatile. Parmi eux, le premier thread vérifie en permanence si flag est true, et s'il est true, il génère les informations correspondantes tandis que le deuxième thread ; passe 1 seconde Après avoir attendu, définissez flag sur true. En utilisant le mot-clé volatile, nous assurons la visibilité du flag, c'est-à-dire que le thread 1 peut voir la modification du flag par le thread 2 dans le temps . volatile修饰符修饰的共享变量flag来实现线程之间的通信。其中，第一个线程不断检查flag是否为true，如果为true则输出相应信息；而第二个线程经过1秒的等待后将flag设置为true。通过使用volatile关键字，我们保证了flag的可见性，即线程1能够及时看到线程2对flag的修改。

指令重排序：
指令重排序是编译器或处理器为了提高程序性能而对指令序列重新排序的一种优化技术。在单线程环境下，指令重排序不会影响程序的运行结果。然而，在多线程环境下，由于指令重排序可能导致指令的执行顺序发生变化，从而影响到程序的正确性。

Java中的指令重排序主要分为以下三种类型：

编译器重排序：由编译器在编译阶段对指令进行重新排序。
处理器重排序：由处理器在执行阶段对指令进行重新排序。
内存重排序：由内存系统对读/写操作进行重新排序。

为了避免指令重排序带来的问题，Java提供了一些关键字来禁止或限制指令重排序：

volatile：修饰的共享变量禁止重排序，保证变量的读写操作具有顺序性。
synchronized：对于加锁的代码块，保证其内部的指令不会和锁代码之外的指令重排序。
final：修饰的变量一旦初始化完成，不允许再次修改。

代码示例：

public class ReorderingDemo {
    private static int x = 0;
    private static int y = 0;
    private static volatile boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            x = 1;
            flag = true;
        }).start();

        new Thread(() -> {
            if (flag) {
                y = x;
            }
            System.out.println("y = " + y);
        }).start();
    }
}

Copier après la connexion

在上述示例中，我们通过volatile关键字来禁止对flag的重排序。在主线程中，我们启动了两个子线程，其中第一个子线程将x设置为1并将flag设置为true。而第二个子线程中检查flag，如果为true则将y赋值为x的值。由于使用了volatile关键字，我们保证了所有线程对flag的读写操作具有顺序性，从而避免了指令重排序带来的问题。