Detaillierte Erläuterung der Java-Thread-Synchronisation und der Synchronisationsmethoden

Dieser Artikel stellt Java-Threads hauptsächlich anhand von Beispielen vor: Thread-Synchronisierung – Synchronisierungsmethode. Freunde in Not können sich darauf beziehen.

Thread-Synchronisierung soll Multithread-SicherheitZugriff auf konkurrierende Ressourcen gewährleisten . ein Mittel.

Thread-Synchronisierung ist die Schwierigkeit der Java-Multithread-Programmierung Entwickler verstehen oft nicht, was konkurrierende Ressourcen sind, wann Synchronisierung in Betracht gezogen werden muss, wie man synchronisiert usw. Natürlich Auf diese Probleme gibt es keine klare Antwort, aber es gibt einige grundsätzliche Fragen, die berücksichtigt werden müssen. Gibt es konkurrierende Ressourcen, die gleichzeitig geändert werden?

Zur Synchronisierung müssen die folgenden zwei Vorgänge im spezifischen Java-Code ausgeführt werden:

Markieren Sie die um den Zugriff konkurrierende Ressource als privat;

Um den Code zu synchronisieren, der
Variablen

ändert, verwenden Sie das synchronisierte Schlüsselwort, um Methoden oder Codes zu synchronisieren.

Natürlich ist dies nicht die einzige Möglichkeit, die Sicherheit der Parallelität zu kontrollieren.

Anweisungen zur Verwendung des synchronisierten Schlüsselworts

synchronized kann nur nicht abstrakte Methoden markieren und keine Mitgliedsvariablen identifizieren.

Um die Verwendung der Synchronisierungsmethode zu demonstrieren, wurde ein Kreditkartenkonto mit einem anfänglichen Kreditlimit von 1 Million erstellt und anschließend mehrere Vorgänge wie Überziehung und Einzahlung simuliert. Offensichtlich ist das Bankkonto User
object

eine konkurrierende Ressource, und die Kontomethode oper(int x) wird für mehrere gleichzeitige Vorgänge verwendet. Natürlich sollte dieser Methode und dem Kontostand eine Synchronisierung hinzugefügt werden sollte als private Variable festgelegt werden.

Der direkte Zugriff ist verboten.

Ausgabeergebnis:

/** 
* Java线程：线程的同步 
* 
* @author leizhimin 2009-11-4 11:23:32 
*/ 
public class Test { 
  public static void main(String[] args) { 
    User u = new User("张三", 100); 
    MyThread t1 = new MyThread("线程A", u, 20); 
    MyThread t2 = new MyThread("线程B", u, -60); 
    MyThread t3 = new MyThread("线程C", u, -80); 
    MyThread t4 = new MyThread("线程D", u, -30); 
    MyThread t5 = new MyThread("线程E", u, 32); 
    MyThread t6 = new MyThread("线程F", u, 21); 
    t1.start(); 
    t2.start(); 
    t3.start(); 
    t4.start(); 
    t5.start(); 
    t6.start(); 
  } 
} 
class MyThread extends Thread { 
  private User u; 
  private int y = 0; 
   MyThread(String name, User u, int y) { 
    super(name); 
    this.u = u; 
    this.y = y; 
  } 
  public void run() { 
    u.oper(y); 
  } 
} 
class User { 
  private String code; 
  private int cash; 
  User(String code, int cash) { 
    this.code = code; 
    this.cash = cash; 
  } 
  public String getCode() { 
    return code; 
  } 
  public void setCode(String code) { 
    this.code = code; 
  } 
  /** 
   * 业务方法 
   * @param x 添加x万元 
   */ 
  public synchronized void oper(int x) { 
    try { 
      Thread.sleep(10L); 
      this.cash += x; 
      System.out.println(Thread.currentThread().getName() + "运行结束，增加“" + x + "”，当前用户账户余额为：" + cash); 
      Thread.sleep(10L); 
    } catch (InterruptedException e) { 
      e.printStackTrace(); 
    } 
  } 
  @Override 
  public String toString() { 
    return "User{" + 
        "code='" + code + '\'' + 
        ", cash=" + cash + 
        '}'; 
  } 
}

Negatives Lehrmaterial, nicht synchronisierte Situation, das heißt, die synchronisierte Änderung des Betriebs entfernen( int x) Methodensymbol und führen Sie dann das Programm aus. Das Ergebnis lautet wie folgt:

线程A运行结束，增加“20”，当前用户账户余额为：120 
线程F运行结束，增加“21”，当前用户账户余额为：141 
线程E运行结束，增加“32”，当前用户账户余额为：173 
线程C运行结束，增加“-80”，当前用户账户余额为：93 
线程B运行结束，增加“-60”，当前用户账户余额为：33 
线程D运行结束，增加“-30”，当前用户账户余额为：3

Offensichtlich ist das obige Ergebnis falsch. Der Grund für den Fehler ist, dass mehrere Threads gleichzeitig auf die zugreifen Die

Attribute

线程A运行结束，增加“20”，当前用户账户余额为：61 
线程D运行结束，增加“-30”，当前用户账户余额为：63 
线程B运行结束，增加“-60”，当前用户账户余额为：3 
线程F运行结束，增加“21”，当前用户账户余额为：61 
线程E运行结束，增加“32”，当前用户账户余额为：93 
线程C运行结束，增加“-80”，当前用户账户余额为：61

der konkurrierenden Ressource u und modifizieren u wurden geändert.

Sie sehen, wie wichtig die Synchronisierung ist.

Hinweis:

Wie aus dem vorherigen Artikel hervorgeht, wenn der Thread die Synchronisierungsmethode

verlässt, wird die Die Sperre des Objekts, zu dem die Methode gehört, wird freigegeben. Es ist jedoch auch zu beachten, dass bestimmte Methoden auch zum Einplanen von Threads in Synchronisationsmethoden verwendet werden können. Diese Methoden stammen aus der Klasse java.lang.Object.

Durch die Kombination der oben genannten Methoden ist es sehr wichtig, sich mit Problemen der Multithread-Synchronisierung und des gegenseitigen Ausschlusses zu befassen. Das berühmte Producer-Consumer-Beispiel ist ein klassisches Beispiel, das für Multithreading in jedem Fall gelernt werden muss Sprache.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Java-Thread-Synchronisation und der Synchronisationsmethoden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!