Beispielanalyse für Java-Thread-Sicherheit und Synchronisierung

Thread-Sicherheitsprobleme

Mehrere Threads können dieselbe Ressource gemeinsam nutzen (auf sie zugreifen)

Zum Beispiel auf dasselbe Objekt, dieselbe Variable, dieselbe Datei zugreifen#🎜 🎜#

Wenn mehrere Threads auf dieselbe Ressource zugreifen, kann es leicht zu Datenverwirrungen und Datensicherheitsproblemen kommen, die als Thread-Sicherheitsprobleme bezeichnet werden.

Unter welchen Umständen treten Thread-Sicherheitsprobleme auf?#🎜 🎜 #

Mehrere Threads teilen sich dieselbe Ressource

Und mindestens ein Thread führt den Schreibvorgang aus

Beispiel:

Geld sparen Das Problem des Geldabhebens

Es gibt zwei Threads zum Ein- und Auszahlen von Geld

Geld einzahlen

Thread 1 Balance Thread 2

1000 "----1000------" 1000
1000+1000-----"2000
500 "-----1000-500
#🎜🎜 #
Richtig: Der Restbetrag nach dem Ende sollte 1500 betragen, nicht 500

Kaufproblem

Es gibt 2 Threads, die Tickets verkaufen

#票#

Thread 1 Abstimmung Thread 2

1000 "--- 1000 ------" 1000

1000-1 ----- "999

            999 "- ----1000-1


Richtig: Der Saldo nach dem Ende sollte 998 sein, nicht 999

Falsche Frage zum Ticketkauf (Nicht Thread synchronisiert) Beispiel :

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

Teilausgabeergebnis:

Thread-Sicherheitsproblem

#🎜🎜 #Analyseproblem#🎜🎜 #Threads A und B führen eine +1-Operation für eine Variable in der Klasse mit einem Wert von 17 aus

Das Endergebnis ist 2 18

Lösung#🎜 🎜##🎜 🎜# Sperren:

Prozess: Zuerst greift Thread A auf diese 17 zu, liest sie, sperrt sie und gibt die +1-Operation ein, um sie in 18# zu ändern. 🎜🎜# und 17 befindet sich während des Sperrzeitraums , andere Threads können nicht darauf zugreifen

Schreiben Sie nach der Änderung 17
Dann greifen Sie darauf zu, sperren Sie es erneut, wiederholen Sie den obigen Vorgang, um 19 zu werden, und entsperren Sie es dann Stellt sicher, dass nur ein Thread gleichzeitig darauf zugreift, wodurch die Sicherheit gewährleistet ist. Der vorherige Fehler war darauf zurückzuführen, dass diese Threads gemeinsam darauf zugegriffen haben ist Thread-Synchronisationstechnologie

Thread-Synchronisationstechnologie kann zur Lösung von Thread-Sicherheitsproblemen verwendet werden

In Java gibt es zwei Arten der Thread-Synchronisation Methode:

1. Synchrone Anweisung

2. Synchrone Methode

Synchronische Anweisung

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

Ergebnisse der Teilausgabe: # 🎜🎜#

#🎜🎜 #

Prinzip von synchronisieren(obj)

1 Jedem Objekt ist eine intrinsische Sperre zugeordnet, die als Monitorsperre bezeichnet wird Der erste Thread, der die Synchronisationsanweisung ausführt, kann die interne Sperre von obj erhalten und die Sperre freigeben, nachdem er den Code in der Synchronisationsanweisung ausgeführt hat #🎜 🎜#

3 Solange ein Thread die interne Sperre hält, werden andere Threads nicht nicht mehr in der Lage sein, diese Sperre gleichzeitig zu erhalten

✓ Wenn sie versuchen, diese Sperre zu erhalten, gelangen sie in den Status „BLOCKIERT“

4, wenn mehrere Threads synchronisiert auf dasselbe zugreifen (obj)-Anweisung

obj muss dasselbe Objekt sein, um eine Synchronisierung zu erreichen

#🎜 🎜#Synchronisierte Methode

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 kann den Konstruktor nicht ändern

# 🎜🎜#Die Essenz der synchronisierten Methode

Instanzmethode: synchronisiert (dies)

# 🎜🎜#Statische Methode: synchronisiert (Klassenobjekt)

Synchronisierte Anweisungen sind flexibler als synchrone Methoden

Synchronisierte Anweisungen können den Codebereich, der gesperrt werden muss, genau steuern, wodurch die Notwendigkeit reduziert wird, den Status-Thread zu blockieren und die Arbeit voll auszunutzen

Nachher Verwendung der Thread-Synchronisationstechnologie

Obwohl das Thread-Sicherheitsproblem gelöst ist, verringert es die Ausführungseffizienz des Programms

#🎜🎜 #Denn wenn eine Sperre hinzugefügt wird, gibt es wartende Threads und Es gibt mehr Sperr- und Entsperrvorgänge

Verwenden Sie daher die Thread-Synchronisierungstechnologie nur, wenn es wirklich notwendig ist

Das obige ist der detaillierte Inhalt vonBeispielanalyse für Java-Thread-Sicherheit und Synchronisierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!