Quel impact la méthode synchronisée a-t-elle sur la méthode non synchronisée ?

StringBuilder est une classe non sécurisée pour les threads.

StringBuffer est thread-safe car les méthodes qu'il contient sont synchronisées.

J'ai écrit un morceau de code aujourd'hui pour le tester : utilisez une boucle pour ouvrir 10 threads et appelez l'ajout de StringBuffer (StringBuilder) pour en ajouter 1 à 10.

Les résultats sont les mêmes que prévu : StringBuilder non sécurisé pour les threads manquera certains chiffres,

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-safe Le StringBuffer ajoute les 10 nombres :

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);
}

À ce moment : Si j'opère en même temps le constructeur et le tampon, et l'ajout du premier tampon à ce stade, chaque opération est due au fait que le constructeur et le tampon sont dans le même thread, et la méthode du constructeur est transformée en une méthode "synchronisée" car le tampon bloque également le thread. ajoute 10 chiffres

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);
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!