Technologie de protection des threads et de détection des blocages en Java

Technologie de protection des threads et de détection des blocages en Java

Java, en tant que langage de programmation orienté objet largement utilisé dans les applications d'entreprise, possède de puissantes capacités de programmation multithread. Dans le processus d'application réel, la protection des threads et la technologie de détection des blocages sont cruciales, elles peuvent garantir efficacement la sécurité des threads et la fiabilité des applications. Cet article en discutera.

1. Technologie de protection des threads

La protection des threads fait référence à la restriction et au contrôle des ressources partagées pour garantir que les programmes multithread peuvent garantir l'exactitude et l'intégrité des données lorsqu'ils accèdent simultanément à la même ressource partagée. Java fournit trois technologies de protection des threads : les verrous mutex, les sémaphores et les variables de condition.

1. Verrouillage Mutex

Le verrouillage Mutex est la technologie de protection des fils la plus élémentaire. Sous la protection d'un verrou mutex, un seul thread peut accéder aux ressources partagées, et les autres threads doivent attendre que le verrou mutex soit libéré avant de pouvoir y accéder. En Java, les verrous mutex sont principalement implémentés via le mot-clé synchronisé.

Ce qui suit est un exemple simple de verrouillage mutex :

class Counter {
    private int count = 0;
    //使用 synchronized 实现互斥锁
    public synchronized void increment(){
        count += 1;
        //模拟执行某些操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count);
    }
}
public class MutexExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        //创建两个线程并行执行
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                counter.increment();
            }
        });
        t1.start();
        t2.start();
        //等待两个线程执行完毕
        t1.join();
        t2.join();
    }
}

2 Sémaphore

Le sémaphore est une technologie de protection des threads accessible par plusieurs threads. Il maintient le nombre de threads pouvant accéder aux ressources partagées via un compteur. Lorsqu'un thread souhaite accéder aux ressources partagées, il doit d'abord demander un sémaphore. Si le compteur du sémaphore est supérieur à 0, le thread peut accéder aux ressources partagées. sinon le thread doit attendre le sémaphore. Le compteur n'est accessible que s'il est supérieur à 0.

En Java, le sémaphore est principalement implémenté via la classe Semaphore. L'exemple est le suivant :

import java.util.concurrent.Semaphore;
class Counter {
    private int count = 0;
    private Semaphore sem = new Semaphore(1);
    //使用 Semaphore 实现线程保护
    public void increment(){
        try {
            sem.acquire();
            count += 1;
            //模拟执行某些操作
            Thread.sleep(1000);
            System.out.println(count);
            sem.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class SemaphoreExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        //创建两个线程并行执行
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                counter.increment();
            }
        });
        t1.start();
        t2.start();
        //等待两个线程执行完毕
        t1.join();
        t2.join();
    }
}

3 Variable de condition

La variable de condition est une technologie de protection des threads qui permet au thread d'attendre que certaines conditions soient remplies avant de continuer. à exécuter. Il peut être combiné avec Utilisé avec un verrou mutex. En Java, les variables de condition sont principalement implémentées via l'interface Condition et la classe ReentrantLock. Les exemples sont les suivants :

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
class Counter {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();
    private Condition cond = lock.newCondition();
    public void increment() {
        lock.lock();
        try {
            count += 1;
            //模拟执行某些操作
            Thread.sleep(1000);
            System.out.println(count);
            cond.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void waitUntil(int target) {
        lock.lock();
        try {
            while (count < target) {
                cond.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
public class ConditionVariableExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        //创建两个线程并行执行
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            counter.waitUntil(3);
            System.out.println("Target reached");
        });
        t1.start();
        t2.start();
        //等待两个线程执行完毕
        t1.join();
        t2.join();
    }
}

2. Technologie de détection des blocages

Les blocages font référence à plusieurs threads qui s'attendent pour libérer les ressources qu'ils détiennent, ce qui entraîne le programme étant incapable de continuer. Java fournit des outils et des techniques pour détecter et éviter les blocages.

1.jstack

jstack est un outil fourni par l'environnement d'exécution Java, qui peut être utilisé pour afficher l'état du CPU occupé par chaque thread de la machine virtuelle Java, ainsi que les verrous détenus par les threads et les serrures qu'ils attendent. jstack génère la trace de pile du thread pour afficher les ressources occupées par le thread afin de déterminer s'il y a un blocage.

2.jvisualvm

jvisualvm est un outil graphique fourni avec JDK, qui peut être utilisé pour surveiller l'utilisation des ressources telles que les threads, le processeur, la mémoire et la pile. Grâce à jvisualvm, nous pouvons facilement vérifier les ressources occupées par les threads, détecter et diagnostiquer les blocages à temps et prendre les mesures correspondantes en temps opportun.

3.ThreadMXBean

ThreadMXBean est l'une des interfaces de gestion Java. Elle fournit des outils et des méthodes qui peuvent être utilisés pour surveiller et gérer les threads dans la JVM, notamment l'état des threads, l'utilisation du processeur des threads, le verrouillage de l'occupation des threads et la mort des threads. . Verrouillage et autres informations. En utilisant ThreadMXBean, nous pouvons facilement localiser les problèmes de blocage dans le programme et effectuer des ajustements et des optimisations en temps opportun.

Résumé

Cet article fournit une brève introduction et un exemple de démonstration de la technologie de protection des threads et de détection des blocages en Java. Dans le développement réel, nous devons soigneusement comprendre et maîtriser ces technologies pour garantir l'exactitude et la fiabilité des programmes multithread, améliorant ainsi les performances et la stabilité des applications.

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!