Threads sind ein sehr wichtiges Konzept in der Java-Programmierung. In diesem Artikel wird es anhand von Beispielen ausführlich erläutert. Die spezifische Analyse lautet wie folgt:
Zunächst einmal: Wozu dient die Gewindesicherung? Beispiel: Wenn Sie jetzt 30.000 Yuan auf der Bank haben und zur Bank gehen, um das Geld abzuheben, haben Sie nach Eingabe des Passworts bereits den Abhebungsbetrag eingegeben. Wenn Sie beispielsweise 20.000 Yuan eingegeben haben bedeutet, dass die Bank das Geld für Sie erhält. Zu diesem Zeitpunkt gingen auch Ihre Frau und Sie zur Bank, um das Geld abzuheben Meine Frau hebt ebenfalls 20.000 ab, da Ihr Konto zu diesem Zeitpunkt noch 30.000 beträgt, sodass die Bank den gleichen Vorgang auf Seiten Ihrer Frau durchführt. Nachdem Sie beide Ihre jeweiligen Vorgänge abgeschlossen haben, sollte die Bank also immer noch 30.000 auf Ihrem Konto verbucht haben . Eine Anzahlung von 10.000 Yuan, ist das nicht toll? Um dieses Problem zu lösen, wird das Wissen über die Thread-Sperre genutzt. Lassen Sie es uns gemeinsam lernen.
1. Ein Beispiel für eine nicht behandelte Thread-Synchronisation:
öffentliche Klasse TextSync implementiert Runnable{ /**Unbehandelte Thread-Synchronisierung* @param args */ Time time = new Time(); public static void main(String[] args) { TextSync text = new TextSync(); Thread t1 = new Thread (text); Thread t2 = new Thread(text); t1.setName("t1"); t2.start(); } @Override public void run() { time.add(Thread.currentThread().getName() }}class Time { public void add(String name){ try { num++; //Wenn der erste Thread bis zu diesem Punkt ausgeführt wird, wird num für eine Sekunde angehalten. //Der zweite Thread beginnt mit der Ausführung bis zu diesem Punkt. und der zweite Thread pausiert für eine Sekunde. //Die Anzahl des ersten Threads wird zu diesem Zeitpunkt ebenfalls 2, sodass das Endergebnis 2 ist; Thread.sleep(1000); " ist der "+num+"-te Thread der Ausführung." }}Ausgabeergebnis:
t2 ist der zweite Ausführungsthread. t1 ist der zweite Ausführungsthread.
2. Thread-Synchronisation
öffentliche Klasse TextSynctwo implementiert Runnable{ /**Thread-Synchronisation* @param args */ Time1 time = new Time1(); public static void main(String[] args) { TextSynctwo text = new TextSynctwo(); text); Thread t2 = new Thread(text); t1.setName("t1"); t1.start(); t2.start(); } @Override public void run() { time.add(Thread.currentThread().getName() }}class Time1 { private static int = 0; synchronisiert sperrt den aktuellen Thread, der bei der Definition der Methode deklariert oder in der Methode festgelegt werden kann. public synchronisiert void add(String name){ //synchronized (this) {//Sperren Sie den aktuellen Thread, um zu verhindern, dass er von anderen Threads ausgeführt wird try { num++; . printStackTrace(); } System.out.println(name+"ist der "+num+"-te Thread der Ausführung." //} }}Ausgabeergebnis:
t1 ist der erste Ausführungsthread. t2 ist der zweite Ausführungsthread.
3. Stillstand
öffentliche Klasse TestDeadLock implementiert Runnable{ /**Deadlock* @param args */ private int flag = 0; static Object(); public static void main(String[] args ) { TestDeadLock td1 = new TestDeadLock(); TestDeadLock td2 = new TestDeadLock(); = 1; td2.flag = 2; Thread t1 = new Thread(td1); Thread t1.setName("t1"); ; t2.start(); } @Override public void run() { System.out.println(Thread.currentThread().getName()); if(flag == 1){ synchronisiert(o1){ try { Thread.sleep(5000 } Catch (InterruptedException e) { e.printStackTrace( ); } synchronisiert(o2){ System.out.println("1" } } } if(flag == 2){ synchronisiert(o2){ try { Thread.sleep(5000); } Catch (InterruptedException e) { e.printStackTrace(); } synchronisiert(o1){ System.out.println("2");4. Sperren
öffentliche Klasse TT implementiert Runnable{ /**Lock* @param args */ int b = 100; public static void main(String[] args) { TT tt = new TT(); .start(); try { tt.m2(); Exception e) { e.printStackTrace(} System.out.println(tt.b); } @Override public void run() { try { m1(); } Catch (Exception e) { e.printStackTrace(); b = 1000; Thread.sleep(5000); System.out.println("b="+b } privatescribed void m2() throws Ausnahme{ Thread.sleep(2500); b = 2500; }Die Ausgabe ist nun:
1000b=1000
Es ist ersichtlich, dass m2 zuerst ausgeführt wird und m1 erst ausgeführt werden kann, wenn m2 abgeschlossen ist.
Ich hoffe, dass dieser Artikel für das Java-Programmierdesign aller hilfreich sein wird.