Démystifier le modèle de mémoire Java : maîtriser les secrets de la programmation multithread

l'éditeur php Yuzai vous emmène révéler le modèle de mémoire Java et acquérir une compréhension approfondie des mystères derrière la programmation multithread. La programmation multithread est une compétence importante dans le développement Java, et la compréhension du modèle de mémoire est cruciale pour écrire des programmes multithread efficaces et fiables. Explorons ensemble le modèle de mémoire Java et découvrons le mystère de la programmation multithread !

L'objectif principal de JMM est de garantir l'exactitude et la prévisibilité des programmes multi-thread. Il évite les courses de données et les problèmes de cohérence de la mémoire en définissant un ensemble de règles pour réguler l'accès des threads à la mémoire partagée. Les principes de base de JMM incluent :

• Visibilité :  Les modifications des variables partagées par les threads doivent être reflétées dans la plage visible des autres threads en temps opportun.
• Atomicité : Les opérations de lecture et d'écriture sur les variables partagées sont atomiques, c'est-à-dire ininterruptibles.
• Ordre : L'ordre dans lequel les threads accèdent aux variables partagées doit être cohérent avec l'ordre d'exécution dans le programme.

Pour réaliser ces principes de base, JMM introduit les concepts clés suivants :

• Mémoire principale : La mémoire principale est l'espace mémoire physique partagé par tous les threads.
• Mémoire de travail : Chaque thread possède sa propre mémoire de travail, qui stocke une copie des variables privées du thread.
• Protocole de cohérence du cache : CacheLe protocole de cohérence est un protocole utilisé pour garantir que les données dans les caches de plusieurs processeurs restent cohérentes.

Lorsqu'un thread modifie une variable partagée, il écrit la valeur modifiée dans la mémoire principale. D'autres threads peuvent obtenir la dernière valeur en lisant la valeur dans la mémoire principale. Cependant, en raison de la latence du protocole de cohérence du cache, les autres threads peuvent ne pas voir immédiatement la valeur modifiée. Pour résoudre ce problème, JMM introduit le concept de barrière mémoire. Une barrière de mémoire force un thread à écrire immédiatement les valeurs modifiées dans la mémoire principale et garantit que les autres threads peuvent voir les valeurs modifiées.

Le langage Java fournit le mot-clé synchronized 和 volatile 两个关键字来实现线程同步和可见性。synchronized 关键字可以保证对共享变量的访问是原子的，volatile pour garantir que les modifications apportées aux variables partagées sont visibles.

Voici un code de démonstration montrant comment utiliser le mot-clé synchronized 和 volatile pour obtenir la synchronisation et la visibilité des threads :

class SharedCounter {
private int count = 0;

public synchronized void increment() {
count++;
}

public int getCount() {
return count;
}
}

public class Main {
public static void main(String[] args) {
SharedCounter counter = new SharedCounter();

Thread thread1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
counter.increment();
}
});

Thread thread2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
counter.increment();
}
});

thread1.start();
thread2.start();

try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("Final count: " + counter.getCount());
}
}

Dans cet exemple, nous utilisons synchronized 关键字来保证对 count l'accès à la variable pour être atomique, évitant ainsi les problèmes de course aux données.

class SharedCounter {
private volatile int count = 0;

public void increment() {
count++;
}

public int getCount() {
return count;
}
}

public class Main {
public static void main(String[] args) {
SharedCounter counter = new SharedCounter();

Thread thread1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
counter.increment();
}
});

Thread thread2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
System.out.println("Current count: " + counter.getCount());
}
});

thread1.start();
thread2.start();

try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

Dans cet exemple, nous utilisons volatile 关键字来保证对 count 变量的修改是可见的，从而使线程 2 能够及时地看到线程 1 对 count la modification de la variable.

Une compréhension approfondie du modèle de mémoire Java est cruciale pour résoudre les problèmes de Programmation simultanée. En maîtrisant les principes de base et les concepts clés de JMM, les programmeurs peuvent écrire des programmes multithread plus robustes et prévisibles.

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!