Beispielcode für verschiedene Methoden zur ordnungsgemäßen Ausführung von Java-Multithreads

In diesem Artikel werden hauptsächlich relevante Informationen zur Zusammenfassung mehrerer Methoden zur ordnungsgemäßen Ausführung von Java-Multithreads vorgestellt. Freunde in Not können sich auf Folgendes beziehen:

Mehrere Methoden zur ordnungsgemäßen Ausführung von Java-Multithreads. Threads.

Ein Kollege hat diese Frage versehentlich aufgeworfen und zwei Methoden persönlich geübt. Natürlich gibt es definitiv mehr und bessere Möglichkeiten.

Methode 1

import java.util.concurrent.atomic.AtomicInteger;

public class OrderedThread1 {
 
 static AtomicInteger count = new AtomicInteger(0);

 public static void main(String[] args) throws InterruptedException {
 Task task1 = new Task(count, 0);
 Task task2 = new Task(count, 1);
 Task task3 = new Task(count, 2);
 Thread thread1 = new Thread(task1);
 Thread thread2 = new Thread(task2);
 Thread thread3 = new Thread(task3);
 thread1.setDaemon(true);
 thread2.setDaemon(true);
 thread3.setDaemon(true);
 thread1.start();
 thread2.start();
 thread3.start();
 
 Thread.sleep(1 * 1000);
 }

}

class Task implements Runnable {
 
 private AtomicInteger count;
 private int order;
 
 public Task(AtomicInteger count, int order) {
 this.count = count;
 this.order = order;
 }

 @Override
 public void run() {
 while (true) {
  if (count.get() % 3 == order) {
  System.out.println(Thread.currentThread().getName() + " ===== "+ order);
  count.incrementAndGet();
  }
 }
 }
}

Diese Methode sollte eine häufigere Lösung sein. Verwenden Sie ein atomares Inkrement, um die Thread-Zulassungsreihenfolge zu steuern.

Methode 2

public class OrderedThread2 {
 static Holder holder = new Holder();
 public static void main(String[] args) throws InterruptedException {
 
 Task1 task1 = new Task1(holder, 0);
 Task1 task2 = new Task1(holder, 1);
 Task1 task3 = new Task1(holder, 2);
 Thread thread1 = new Thread(task1);
 Thread thread2 = new Thread(task2);
 Thread thread3 = new Thread(task3);
 thread1.setDaemon(true);
 thread2.setDaemon(true);
 thread3.setDaemon(true);
 thread1.start();
 thread2.start();
 thread3.start();
 
 Thread.sleep(1 * 1000);
 

 }

}

class Task1 implements Runnable {
 
 Holder holder;
 int order;
 
 public Task1(Holder holder, int order) {
 this.holder = holder;
 this.order = order;
 }

 @Override
 public void run() {
 while (true) {
  if (holder.count % 3 == order) {
  System.out.println(Thread.currentThread().getName() + " ===== "+ order);
  holder.count ++;
  }
 }
// int i = 0;
// while(i ++ < 10000){
//  holder.count ++;
// }
 }
}
class Holder {
 volatile int count = 0;
}

Methode 2 verwendet das Schlüsselwort volatile. Lassen Sie jeden Thread den neuesten Zählwert erhalten. Wenn einer der Threads die ++-Operation ausführt, erhalten die anderen beiden Threads den neuesten Wert und prüfen, ob die Zulassungsbedingungen erfüllt sind.

ps: volatile ist nicht threadsicher. Und die beiden haben nichts miteinander zu tun. Flüchtige Variablen behalten keine Kopien in Benutzer-Threads und stellen daher allen Threads den neuesten Wert zur Verfügung. Aber stellen Sie sich vor, wenn mehrere Threads gleichzeitig die Variable aktualisieren, ist das Ergebnis offensichtlich. Das letzte Update überschreibt alle vorherigen Updates, was zu Thread-Unsicherheit führt. Bei Methode zwei erfüllt jeweils nur ein Thread die Zulassungsbedingung , sodass keine gleichzeitige Aktualisierung von Variablen erfolgt. Die Aktualisierung flüchtiger Werte ist für die Thread-Sicherheit völlig irrelevant. Missbrauchen Sie daher flüchtige Werte nicht zur Implementierung der Parallelitätskontrolle.

Das obige ist der detaillierte Inhalt vonBeispielcode für verschiedene Methoden zur ordnungsgemäßen Ausführung von Java-Multithreads. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!