Welchen Einfluss hat die synchronisierte Methode auf die nicht synchronisierte Methode?

StringBuilder ist eine Thread-unsichere Klasse.

StringBuffer ist threadsicher, da die darin enthaltenen Methoden synchronisiert sind.

Heute habe ich einen Code geschrieben, um ihn zu testen: Verwenden Sie eine Schleife, um 10 Threads zu öffnen, und rufen Sie das Anhängen von StringBuffer (StringBuilder) auf, um 1 zu 10 hinzuzufügen.

Die Ergebnisse sind die gleichen wie erwartet: Thread-unsicherer StringBuilder wird einige Zahlen übersehen,

public static void main(String[] args) throws InterruptedException {
        StringBuffer buffer = new StringBuffer();
        StringBuilder builder = new StringBuilder();        // 开启十个线程，分别对buffer 和 builder 操作        
        for(int i = 0; i < 10; i++) {            
            int j = i;            
            new Thread(new Runnable() {                
            public void run() {                    
            try {
                        Thread.sleep(500); //造成阻塞
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    builder.append(j);
                }
            }).start();
        }        //等待以上操作完成
        Thread.sleep(1000);        // 打印结果
        System.out.println("builder:"+builder);
    }

Thread-sicher Der StringBuffer hängt alle 10 Zahlen an:

public static void main(String[] args) throws InterruptedException {
    StringBuffer buffer = new StringBuffer();
    StringBuilder builder = new StringBuilder();    // 开启十个线程，分别对buffer 和 builder 操作        
    for(int i = 0; i < 10; i++) {        
        int j = i;        
        new Thread(new Runnable() {            
        public void run() {                
        try {
                    Thread.sleep(500); //造成阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                buffer.append(j);
            }
        }).start();
    }    //等待以上操作完成
    Thread.sleep(1000);    // 打印结果
    System.out.println("buffer:"+buffer);
}

Zu diesem Zeitpunkt: Wenn ich operiere Gleichzeitiger Builder und Puffer. Zu diesem Zeitpunkt erfolgt jeder Vorgang, da sich der Builder und der Puffer im selben Thread befinden und die Methode des Builders in eine „synchronisierte“ Methode umgewandelt wird, da der Puffer blockiert ist Dem Thread sind auch 10 Zahlen beigefügt

public static void main(String[] args) throws InterruptedException {
    StringBuffer buffer = new StringBuffer();
    StringBuilder builder = new StringBuilder();    // 开启十个线程，分别对buffer 和 builder 操作        
    for(int i = 0; i < 10; i++) {        
        int j = i;        
        new Thread(new Runnable() {            
        public void run() {                
        try {
                    Thread.sleep(500); //造成阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                buffer.append(j);
                builder.append(j);
            }
        }).start();
    }    //等待以上操作完成
    Thread.sleep(1000);    // 打印结果
    System.out.println("buffer:"+buffer);
    System.out.println("builder:"+builder);
}

Das obige ist der detaillierte Inhalt vonWelchen Einfluss hat die synchronisierte Methode auf die nicht synchronisierte Methode?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!