Java-Klassensperre, Objektsperre, Konflikttest für private Sperren

Werden Klassensperren und Objektsperren in Konflikt geraten? Kommt es zu Konflikten zwischen Objektsperren und privaten Sperren? Erklären Sie anhand von Beispielen.

1. Relevante Konventionen

Um die Beschreibung unten zu verdeutlichen, werden die folgenden Konventionen zu den relevanten Definitionen von Sperren in diesem Artikel getroffen:

1 : Fügen Sie im Code statische und synchronisierte Sperren zu den Methoden im Code oder zu synchronisierten (xxx.class) Codesegmenten hinzu, z. B. increament() unten.

2 die Codesperre oder das synchronisierte (diese) Codesegment, wie z. B. synOnMethod() und synInMethod() unten;

3. Private Sperre: Deklarieren Sie eine private Eigenschaft wie z. B. private Objektsperre innerhalb der Klasse und sperren Sie sie Bei Bedarf wird das Codesegment synchronisiert (Sperre), z. B. synMethodWithObj() unten.

2. Testen Sie den Code

1. Schreiben Sie eine Thread-Klasse ObjThread, um die Synchronisationsmethode zu starten (beachten Sie, dass sie ausgeführt wird). kann für verschiedene Tests angepasst werden)

public class ObjectLock {
 public static void main(String[] args) {
  System.out.println("start time = " + System.currentTimeMillis()+"ms");
  LockTestClass test = new LockTestClass();
  for (int i = 0; i < 3; i++) {
   Thread thread = new ObjThread(test, i);
   thread.start();
  }
 }
}

3. Schreiben Sie eine Sperrtestklasse LockTestClass, einschließlich verschiedener Sperrmethoden

public class ObjThread extends Thread {
 LockTestClass lock;
 int i = 0;
 public ObjThread(LockTestClass lock, int i) {
  this.lock = lock;
  this.i = i;
 }
 public void run() {
  //无锁方法
//  lock.noSynMethod(this.getId(),this);
  //对象锁方法1，采用synchronized synInMethod的方式
  lock.synInMethod();
  //对象锁方法2，采用synchronized(this)的方式
//  lock.synOnMethod();
  //私有锁方法，采用synchronized(object)的方式
//  lock.synMethodWithObj();
  //类锁方法，采用static synchronized increment的方式
  LockTestClass.increment();
 }
}

3. Testergebnisse

public class LockTestClass {
 //用于类锁计数
 private static int i = 0;
    //私有锁
 private Object object = new Object();
 /**
  * <p>
  * 无锁方法
  *
  * @param threadID
  * @param thread
  */
 public void noSynMethod(long threadID, ObjThread thread) {
  System.out.println("nosyn: class obj is " + thread + ", threadId is"
    + threadID);
 }
 /**
  * 对象锁方法1
  */
 public synchronized void synOnMethod() {
  System.out.println("synOnMethod begins" + ", time = "
    + System.currentTimeMillis() + "ms");
  try {
   Thread.sleep(2000L);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("synOnMethod ends");
 }
 /**
  * 对象锁方法2,采用synchronized (this)来加锁
  */
 public void synInMethod() {
  synchronized (this) {
   System.out.println("synInMethod begins" + ", time = "
     + System.currentTimeMillis() + "ms");
   try {
    Thread.sleep(2000L);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("synInMethod ends");
  }
 }
 /**
  * 对象锁方法3
  */
 public void synMethodWithObj() {
  synchronized (object) {
   System.out.println("synMethodWithObj begins" + ", time = "
     + System.currentTimeMillis() + "ms");
   try {
    Thread.sleep(2000L);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("synMethodWithObj ends");
  }
 }
 /**
  * 类锁
  */
 public static synchronized void increament() {
  System.out.println("class synchronized. i = " + i + ", time = "
    + System.currentTimeMillis() + "ms");
  i++;
  try {
   Thread.sleep(2000L);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
   System.out.println("class synchronized ends.");
 }
}

1. Testklassensperre und Objektsperre werden wie folgt geändert:

Terminalausgabe:

public void run() {
  //无锁方法
//  lock.noSynMethod(this.getId(),this);
  //对象锁方法1，采用synchronized synInMethod的方式
  lock.synInMethod();
  //对象锁方法2，采用synchronized(this)的方式
//  lock.synOnMethod();
  //私有锁方法，采用synchronized(object)的方式
//  lock.synMethodWithObj();
  //类锁方法，采用static synchronized increment的方式
  LockTestClass.increament();
 }

Sie können sehen, dass die Objektsperrmethode (synInMothod) 2 ist Sekunden schneller als die Klassensperrmethode (Inkrementierung), wenn sie zum ersten Mal gestartet wird. Dies liegt daran, dass synInMehtod bei der Ausführung 2 Sekunden lang schläft und dann die Inkrementierung ausführt und diese beiden Methoden denselben Thread teilen, sodass sie 2 Sekunden langsamer ist Wenn increament es in run vor synInMethod gesetzt wird, wird es beim ersten Start um 2 Sekunden schneller erhöht.

start time = 1413101360231ms
synInMethod begins, time = 1413101360233ms
synInMethod ends
class synchronized. i = 0, time = 1413101362233ms
synInMethod begins, time = 1413101362233ms
class synchronized ends.
synInMethod ends
class synchronized. i = 1, time = 1413101364233ms
synInMethod begins, time = 1413101364233ms
class synchronized ends.
synInMethod ends
class synchronized. i = 2, time = 1413101366234ms
class synchronized ends.

Wenn die Klassensperrmethode gestartet wird, wird fast gleichzeitig auch die Objektsperrmethode eines anderen Threads gestartet, was darauf hinweist, dass die beiden nicht dieselbe Sperre verwenden und es keine Konkurrenz gibt.

Schlussfolgerung: Klassensperren und Objektsperren konkurrieren nicht und ihre Sperrmethoden beeinflussen sich nicht gegenseitig.

2. Private Sperre und Objektsperre, die Ausführungsmethode von ObjectThread wird wie folgt geändert:

Terminalausgabe:

public void run() {
  //无锁方法
//  lock.noSynMethod(this.getId(),this);
  //对象锁方法1，采用synchronized synInMethod的方式
  lock.synInMethod();
  //对象锁方法2，采用synchronized(this)的方式
//  lock.synOnMethod();
  //私有锁方法，采用synchronized(object)的方式
  lock.synMethodWithObj();
  //类锁方法，采用static synchronized increment的方式
//  LockTestClass.increament();
 }

Es ist sehr ähnlich Klassensperre und Objektsperre.

start time = 1413121912406ms
synInMethod begins, time = 1413121912407ms.
synInMethod ends.
synMethodWithObj begins, time = 1413121914407ms
synInMethod begins, time = 1413121914407ms.
synInMethod ends.
synMethodWithObj ends
synInMethod begins, time = 1413121916407ms.
synMethodWithObj begins, time = 1413121916407ms
synInMethod ends.
synMethodWithObj ends
synMethodWithObj begins, time = 1413121918407ms
synMethodWithObj ends

Fazit: Private Sperren und Objektsperren konkurrieren nicht und ihre Sperrmethoden beeinflussen sich nicht gegenseitig.

3.synchronized wird direkt zur Methode hinzugefügt und synchronisiert (diese). Die Ausführungsmethode von ObjectThread wird wie folgt geändert:

Terminalausgabe:

public void run() {
  //无锁方法
//  lock.noSynMethod(this.getId(),this);
  //对象锁方法1，采用synchronized synInMethod的方式
  lock.synInMethod();
  //对象锁方法2，采用synchronized(this)的方式
  lock.synOnMethod();
  //私有锁方法，采用synchronized(object)的方式
//  lock.synMethodWithObj();
  //类锁方法，采用static synchronized increment的方式
//  LockTestClass.increament();
 }

Sie können darauf achten, dass die beiden Ausgaben streng seriell erfolgen (es ist natürlich nicht festgelegt, ob bei der erneuten Ausführung zuerst synInMethod oder synOnMethod ausgeführt wird, je nachdem, wer die Sperre erhält).

start time = 1413102913278ms
synInMethod begins, time = 1413102913279ms
synInMethod ends
synInMethod begins, time = 1413102915279ms
synInMethod ends
synOnMethod begins, time = 1413102917279ms
synOnMethod ends
synInMethod begins, time = 1413102919279ms
synInMethod ends
synOnMethod begins, time = 1413102921279ms
synOnMethod ends
synOnMethod begins, time = 1413102923279ms
synOnMethod ends

Fazit: Die beiden Sperrmethoden werden direkt zur Methode hinzugefügt und synchronisiert (dies). Die beiden Sperrmethoden stehen in einer Konkurrenzbeziehung und es kann nur eine Methode gleichzeitig ausgeführt werden.

Weitere Artikel zu Java-Klassensperren, Objektsperren und Konflikttests für private Sperren finden Sie auf der chinesischen PHP-Website!