Wie betreibt Java JUC eine Sammlung von List-Sicherheitsklassen?

Unsichere Sammlung

In Single-Thread-Anwendungen wird new ArrayList() normalerweise verwendet, um eine Listensammlung zum Speichern wiederholbarer Daten anzugeben.

Unter Multithreading treten jedoch häufig unerwartete Probleme auf. Der Code lautet wie folgt:

import java.util.*;
public class ListTest {
    public static void main(String[] args) throws InterruptedException {
        // 创建list集合
        //List<String> lists = Arrays.asList("1", "2", "3");
        // 不安全
        List<String> lists = new ArrayList<>();

        // 开启十个线程增加数据
        for (int i = 1; i <= 40; i++) {
            new Thread(()->{
                lists.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(Thread.currentThread().getName()+"=="+lists);
            },String.valueOf(i)).start();
        }
    }
}

Wenn mehrere Threads dieselbe Sammlung von Objektinformationen ausführen, werden häufig Fehlermeldungen zu java.util.ConcurrentModificationException angezeigt.

In Java bereitgestellte Sicherheitsmaßnahmen

In der Java-Sprache wird eine neue Listensammlung, die Klasse java.util.Vector, bereitgestellt. Weitere Informationen finden Sie im folgenden Code:

import java.util.*;
public class ListTest {
    public static void main(String[] args) throws InterruptedException {
        // 创建list集合
        //List<String> lists = Arrays.asList("1", "2", "3");
        // 不安全
        //List<String> lists = new ArrayList<>();
		List<String> lists = new Vector<>();

        // 开启十个线程增加数据
        for (int i = 1; i <= 40; i++) {
            new Thread(()->{
                lists.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(Thread.currentThread().getName()+"=="+lists);
            },String.valueOf(i)).start();
        }
    }
}

Es wird kein java.util.ConcurrentModificationException-Fehler angezeigt Nachricht.

Warum können wir den sicheren Datenbetrieb gewährleisten?

übernimmt eine synchronisierte Sperre für den Methodenausführungsaufrufer, um die Multithread-Sicherheit des Add-Vorgangs zu gewährleisten!

Sichere Listensammlung unter JUC

Unter dem JUC-Paket werden die folgenden Möglichkeiten zum Erstellen einer sicheren Sammlung bereitgestellt.

• Methode 1: Collections.synchronizedList(new ArrayList<>());

import java.util.*;
public class ListTest {
    public static void main(String[] args) throws InterruptedException {
		List<String> lists = Collections.synchronizedList(new ArrayList<>());

        // 开启十个线程增加数据
        for (int i = 1; i <= 40; i++) {
            new Thread(()->{
                lists.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(Thread.currentThread().getName()+"=="+lists);
            },String.valueOf(i)).start();
        }
    }
}

Sehen Sie sich den zugrunde liegenden Quellcode an, um die Logik zu implementieren

Beurteilen Sie den Typ der eingehenden Listensammlung und bestimmen Sie, ob die Der Typ ist java.util.RandomAccess. Wenn ja, verwenden Sie java.util.Collections.SynchronizedRandomAccessList, um die Sammlung zu erstellen. Wenn nicht, verwenden Sie java.util.Collections.SynchronizedList, um die Sammlung zu erstellen.

Die entsprechende Add-Operationslogik im Quellcode lautet wie folgt:

Übernehmen Sie einen synchronisierten Synchronisationscodeblock, um den Add-Vorgang von Daten zu sperren! C-Methode 2: Neue CopyonWriteArrayList ();

Die Einführung im Quellcode von R

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
public class ListTest {
    public static void main(String[] args) throws InterruptedException {
        List<String> lists = new CopyOnWriteArrayList<>();

        // 开启十个线程增加数据
        for (int i = 1; i <= 40; i++) {
            new Thread(()->{
                lists.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(Thread.currentThread().getName()+"=="+lists);
            },String.valueOf(i)).start();
        }
    }
}

lautet wie folgt:

Offensichtlich ist die Logik wie folgt:

Nach dem Aufruf der ADD-Methode , nimm es, nimm es, nimm es, nimm es, nimm die ADD-Methode zu java.util.concurrent.locks.ReentrantLock-Objektinformationen.

1. Rufen Sie lock.lock() auf, um die Sperre zu erhalten!

2. Kopieren Sie das ursprüngliche Array-Objekt und erstellen Sie ein neues Array mit der ursprünglichen Array-Größe + 1.

3. Fügen Sie neue Daten in ein neues Array ein.

4. Jeder Vorgang erfordert schließlich das Aufheben der Sperre!

5. In Bezug auf die Leistung weist der Sperrvorgang unter dem JUC-Paket eine bessere Leistung auf als der synchronisierte!

Das obige ist der detaillierte Inhalt vonWie betreibt Java JUC eine Sammlung von List-Sicherheitsklassen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!