synchronisiert

Vorwort

Ich glaube, jeder hat von Thread-Sicherheitsproblemen gehört. Beim Erlernen von Betriebssystemen sind nur ein Wissenspunkt wichtige Ressourcen Dadurch kann ein Prozess ausgeführt werden. Wenn wir jedoch Multithreading verwenden, können wir den Zugriff und die Änderung nur einer Ressource gleichzeitig steuern. Heute möchten wir darüber sprechen über die zweite Eine Methode: Thread-Synchronisationsblock oder Thread-Synchronisationsmethode (synchronisiert)

Instanz

1. Das Folgende ist ein Beispiel zur Veranschaulichung des Verwenden Sie die Thread-Synchronisierungsmethode synchronized

public class Sychor {public void insert(Thread thread) {for (int i = 0; i < 10; i++) {
            System.out.println(thread.getName() + "输出:  " + i);
        }

    }public static void main(String[] args) {final Sychor sychor = new Sychor();

        Thread t1 = new Thread() {public void run() {
                sychor.insert(Thread.currentThread());
            };
        };

        Thread t2 = new Thread() {public void run() {
                sychor.insert(Thread.currentThread());
            };
        };

        t1.start();
        t2.start();
    }
}

, wobei das Ausgabeergebnis wie folgt aussieht

Aus den obigen Ergebnissen können wir ersehen, dass die beiden Threads hier die

-Methode gleichzeitig ausführen. Fügen wir die insert() hinzu Schlüsselwort zum Originalcode, um zu sehen, was der Effekt ist. Der Code lautet wie folgt: synchronized

public class Sychor {public synchronized void insert(Thread thread) {for (int i = 0; i < 10; i++) {
            System.out.println(thread.getName() + "输出:  " + i);
        }

    }public static void main(String[] args) {final Sychor sychor = new Sychor();

        Thread t1 = new Thread() {public void run() {
                sychor.insert(Thread.currentThread());
            };
        };

        Thread t2 = new Thread() {public void run() {
                sychor.insert(Thread.currentThread());
            };
        };

        t1.start();
        t2.start();
    }
}

Ich werde die laufenden Ergebnisse des nicht auflisten Das obige Programm können Sie selbst ausprobieren.

Das Schlüsselwort bewirkt, dass Threads einzeln ausgeführt werden. synchronized

Natürlich verwenden wir die oben beschriebene Thread-Synchronisationsmethode. Wir können den Thread-Synchronisationsblock verwenden. Diese beiden sind flexibler als der Thread-Synchronisationsblock. Einfach ausgedrückt Der Code, der im Synchronisierungsblock synchronisiert werden muss, lautet wie folgt:

public class Sychor {public void insert(Thread thread) {synchronized (this) {for (int i = 0; i < 10; i++) {
                System.out.println(thread.getName() + "输出:  " + i);
            }
            
        }
        

    }public static void main(String[] args) {final Sychor sychor = new Sychor();

        Thread t1 = new Thread() {public void run() {
                sychor.insert(Thread.currentThread());
            };
        };

        Thread t2 = new Thread() {public void run() {
                sychor.insert(Thread.currentThread());
            };
        };

        t1.start();
        t2.start();
    }
}

Sie können diese Methode anhand des obigen Codes erkennen Sie müssen nur die Codemethoden, die synchronisiert werden müssen, in den Synchronisierungsblock einfügen und den Code, der nicht synchronisiert werden muss, außerhalb

1. Wir wissen, dass

   jedes Objekt eine Sperre hatWenn wir die Thread-Synchronisationsmethode oder den Thread-Synchronisationsblock verwenden, erhalten wir tatsächlich die einzige Sperre für das Objekt , Dann können andere Threads nur ausgeschlossen werden. Dies bedeutet, dass es sich um dasselbe Objekt handelt. Wenn es sich um ein anderes Objekt handelt, funktioniert dies nicht, da verschiedene Objekte unterschiedliche Objektsperren haben. Wir ändern das obige Programm wie folgt:

public class Sychor {public void insert(Thread thread) {synchronized (this) {for (int i = 0; i < 10; i++) {
                System.out.println(thread.getName() + "输出:  " + i);
            }
        }

    }public static void main(String[] args) {//第一个线程Thread t1 = new Thread() {public void run() {
                Sychor sychor = new Sychor();   //在run() 方法中创建一个对象sychor.insert(Thread.currentThread());
            };
        };//第二个线程Thread t2 = new Thread() {public void run() {
                Sychor sychor = new Sychor();  //创建另外的一个对象sychor.insert(Thread.currentThread());
            };
        };

        t1.start();
        t2.start();
    }
}

Aus den obigen Ergebnissen ist ersichtlich, dass der Thread-Synchronisationsblock existiert derzeit überhaupt nicht. Es funktioniert, weil sie die Einfügemethode von

verschiedenen Objekten aufrufen und das Erhalten der Sperre unterschiedlich ist

1. Eins haben wir oben gesagt. Die Thread-Synchronisationsmethode und der Thread-Synchronisationsblock erhalten die Sperre des Objekts. Daher sind die Klammern des Thread-Synchronisationsblocks mit

   gefüllt von this in einer Klasse this

1. Eine Klasse hat auch eine eindeutige Sperre Wenn wir nun ein Objekt zum Aufrufen von Mitgliedsmethoden verwenden, können wir Thread-Synchronisationsmethoden oder Synchronisationsblöcke verwenden, um die einzige Sperre in der Klasse zu erhalten. Dann können wir mehrere Threads steuern, indem wir statische Methoden aufrufen Der Code lautet wie folgt:

public class Sychor {// 静态方法public static synchronized void insert(Thread thread)  
    {for(int i=0;i<10;i++)
        {
            System.out.println(thread.getName()+"输出     "+i);
        }
    }public static void main(String[] args) {//第一个线程Thread t1 = new Thread() {public void run() {
                Sychor.insert(Thread.currentThread());  //直接使用类调用静态方法};
        };//第二个线程Thread t2 = new Thread() {public void run() {
                Sychor.insert(Thread.currentThread());   //直接使用类调用静态方法};
        };

        t1.start();
        t2.start();
    }
}

1. Um Thread-Sicherheit und Synchronisationskontrolle zu erreichen, müssen Sie dasselbe Objekt verwenden, wenn Sie eine nicht synchronisierte Methode oder einen synchronisierten Block darin ausführen Darin müssen Sie dieselbe Klasse verwenden, um

   static

aufzurufen. Wenn ein Thread auf die synchronisierte Methode
1. zugreift und ein anderer Thread darauf zugreift Bei der nicht statischen synchronisierten Methode werden die beiden nicht verwendet. Es liegt ein Konflikt vor, da eine eine Klassensperre und die andere eine Objektsperre ist

   static

Wenn Sie einen Thread-Synchronisationsblock verwenden, dann im Synchronisationsblock Der Code ist zugriffskontrolliert, aber der externe Code ist für alle Threads zugänglich

Wenn ein synchronisierter Codeblock ausgeführt wird. Wenn im Thread eine Ausnahme auftritt, wird
1. automatisch die vom aktuellen Thread belegte Sperre aufheben, sodass es aufgrund von Ausnahmen nicht zu einem Deadlock kommt

   jvm

Referenzartikel

Das obige ist der detaillierte Inhalt vonWas ist synchronisiert? Wie verwende ich synchronisiert?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!