Analyse d'exemples de sécurité et de synchronisation des threads Java

Problèmes de sécurité des threads

Plusieurs threads peuvent partager (accéder) à la même ressource

Par exemple, accéder au même objet, à la même variable, au même fichier

Lorsque plusieurs threads accèdent à la même ressource, il est facile de provoquer une confusion dans les données et des problèmes de sécurité des données, appelés problèmes de sécurité des threads

Dans quelles circonstances des problèmes de sécurité des threads se produiront

Plusieurs threads partagent la même ressource

Et au moins un thread effectue une opération d'écriture

Exemple :

Déposer et retirer de l'argent Argent problème

Il y a deux fils de discussion pour déposer de l'argent et retirer de l'argent respectivement

Déposer de l'argent Retirer de l'argent Fil de discussion 1 Solde Fil de discussion 2
1000 "----1000------" 1000
1000+1000--- - -》2000
                                                                                                                                      Vendre des billets
Sujet 1 Nombre de votes Sujet 2

1000 «----1000------» 1000

1000-1-----»999

999 «-----1000 -1

Correct : fin Le solde final doit être de 998, et non de 999

Erreur de problème d'achat de ticket (pas de thread synchronisé) Exemple :

public class love implements Runnable{
    private int piao=3000;//有3000张票
    public boolean sale() {//ture代表还有票；false代表没有票了
        if(piao<1) return false;
         piao--;//卖1张票
         
         //细化piao--;
         //寄存器=piao;
         //寄存器=寄存器-1；
         //piao=寄存器;
         
         String sk =Thread.currentThread().getName();//获取当前线程(买票窗口)的名字
         System.out.println(sk+"卖了1张票，还剩下"+piao+"张");
         return piao>1;
    }
    public void run() {
         while(sale());//循环执行；直至卖完票返回false
    }
}
 
public class Main {
    public static void main(String[] a) {
        love tjlove =new love();
        for(int i=1;i<=4;i++) {//循环4次；产生4个线程(窗口)卖票
            Thread tj = new Thread(tjlove());
            tj.setName(""+i);
            tj.start();
        }
    }
}

Résultat de sortie partielle :

Problème de sécurité du thread

Problème d'analyse

Les threads A et B dans la valeur de la variable de classe 1 sont 17 pour l'opération +1

Le résultat final est 2 18

Solution

Verrouillage :

Processus : Tout d'abord, le thread A accède d'abord à ce 17, puis le verrouille et entre + 1 après l'avoir lu L'opération est modifiée en 18

et 17 n'est pas accessible aux autres threads pendant la période de verrouillage

Une fois la modification terminée, écrivez-la, puis déverrouillez 17

Ensuite, le thread B y accède, le verrouille à nouveau et répète l'opération ci-dessus devient 19. Déverrouillez-le à nouveau

Cela peut garantir qu'un seul thread y accède en même temps, garantissant ainsi la sécurité ; l'erreur précédente était due au fait que ces threads y accédaient ensemble

Synchronisation des threads

L'opération de verrouillage que je viens de mentionner est la technologie de synchronisation des threads

La technologie de synchronisation des threads peut être utilisée pour résoudre les problèmes de sécurité des threads

La synchronisation des threads a deux méthodes en Java :

1 Déclaration de synchronisation

2 Méthode de synchronisation

Déclaration de synchronisation

public class love implements Runnable{
	private int piao=3000;//本人cpu单核性能过强,数据量大些才能看到是4个线程在卖票
	public boolean sale() {
		synchronized(this) {//1个线程获取这个对象的锁，并加锁；    synchronized作用于整个语句
		//this指向当前对象
		//不能用new Object()；这样会产生新的对象，产生新的锁
		//把this换成"123",效果基本一样；因为其存在常量值里，每次访问的对象一样
			if(piao<1) return false;
			piao--;
			String sk =Thread.currentThread().getName();
			System.out.println(sk+"卖了1张票，还剩下"+piao+"张");
			return piao>0;
			}
	}
	public void run() {
		 while(sale());
	}
}

Résultats de sortie partielle :

Le principe de synchroniser(obj)

1. Chaque objet est associé à un verrou intrinsèque (verrouillage intrinsèque) ou à un verrou de moniteur (verrouillage du moniteur)

2. peut obtenir le verrou interne d'obj et libérer le verrou après avoir exécuté le code dans l'instruction de synchronisation

3 Tant qu'un thread détient le verrou interne, les autres threads ne pourront plus obtenir ce verrou en même temps

. ✓ Lorsqu'ils tentent d'acquérir ce verrou, ils entreront dans l'état BLOQUÉ

4. Lorsque plusieurs threads accèdent à la même instruction synchronisée (obj)

obj doit être le même objet pour réaliser la synchronisation

Méthode de synchronisation

public class love implements Runnable{
    private int piao=3000;
    public synchronized boolean sale() { //synchronized作用于整个方法
            if(piao<1) return false;
            piao--;
            String sk =Thread.currentThread().getName();
            System.out.println(sk+"卖了1张票，还剩下"+piao+"张");
            return piao>0;
    }
    public void run() {
         while(sale());
    }
}

synchronized ne peut pas modifier le constructeur

L'essence des méthodes synchronisées

Méthode d'instance : synchronisée (this)

Méthode statique : synchronisée (objet Classe)

Les instructions synchronisées sont plus flexibles que les méthodes synchrones

Les instructions synchronisées peuvent contrôler précisément les besoins d'être ajouté La portée du code du verrou réduit le nombre de threads à l'état BLOQUÉ et utilise pleinement le travail

Après avoir utilisé la technologie de synchronisation des threads

Bien que le problème de sécurité des threads soit résolu, il réduit l'efficacité d'exécution du programme

Parce que l'ajout d'un verrou fera attendre les gens. Les threads ont des opérations de verrouillage et de déverrouillage supplémentaires

N'utilisez donc la technologie de synchronisation des threads que lorsque cela est vraiment nécessaire

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!