Diferencia entre colecciones tradicionales y colecciones concurrentes en java

Todos conocemos las colecciones tradicionales (es decir , List , Set , Queue y sus clases implementadas) y las colecciones concurrentes (es decir, la interfaz ConcurrentMap, la clase ConcurrentHashMap, la clase CopyOnWriteArrayList, etc.). En estas dos colecciones, hay pocas diferencias como:

• La mayoría de las clases que están presentes en las colecciones tradicionales (es decir , ArrayList , LinkedList , HashMap , etc.) no están sincronizadas por naturaleza y, por lo tanto, no hay seguridad para subprocesos. Pero todas las clases presentes en colecciones concurrentes están sincronizadas por naturaleza. Por lo tanto, en las clases concurrentes, no tenemos que preocuparnos por la seguridad de subprocesos.
• Mientras que las colecciones tradicionales también tienen algunas clases (como Vector , Stack , etc.) que están sincronizadas por naturaleza, las colecciones tradicionales también tienen métodos SynchronizedSet, SynchronizedList, SynchronizedMap a través de los cuales podemos obtener una versión sincronizada de objetos no sincronizados. Pero estas clases sincronizadas anteriores no son buenas en términos de rendimiento debido al mecanismo de bloqueo amplio. Mientras que el rendimiento de las clases de colecciones simultáneas es relativamente alto que las clases de colecciones tradicionales.
• En las colecciones tradicionales, si un subproceso está iterando un objeto de colección y si otro subproceso intenta agregar un nuevo elemento en ese objeto de iteración simultáneamente, obtendremos RuntimeException ConcurrentModificationException . Mientras que en el caso anterior, no obtendremos ninguna excepción de tiempo de ejecución si estamos trabajando con clases de colecciones concurrentes.
• Las clases de colecciones tradicionales son una buena opción si no estamos tratando con subprocesos en nuestra aplicación. mientras que debido a la colección concurrente/sincronizada podemos usar múltiples subprocesos que se ocupan de objetos de colecciones. Por lo tanto, las colecciones concurrentes son la mejor opción si estamos tratando con varios subprocesos en nuestra aplicación.

// Java program to illustrate Traditional
// Collections Problem
import java.util.*;
class ConcurrentDemo extends Thread {
    static ArrayList l = new ArrayList();
    public void run()
    {
        try {
            Thread.sleep(2000);
        }
        catch (InterruptedException e) {
            System.out.println("Child Thread"
                    + " going to add element");
        }
 
        // Child thread trying to add new
        // element in the Collection object
        l.add("D");
    }
 
    public static void main(String[] args)
        throws InterruptedException
    {
        l.add("A");
        l.add("B");
        l.add("c");
 
        // We create a child thread that is
        // going to modify ArrayList l.
        ConcurrentDemo t = new ConcurrentDemo();
        t.start();
 
        // Now we iterate through the ArrayList
        // and get exception.
        Iterator itr = l.iterator();
        while (itr.hasNext()) {
            String s = (String)itr.next();
            System.out.println(s);
            Thread.sleep(6000);
        }
        System.out.println(l);
    }
}

Producción:

Exception in thread “main” java.util.ConcurrentModificationException

// Java program to illustrate ConcurrentCollection uses
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.*;
class ConcurrentDemo extends Thread {
    static CopyOnWriteArrayList l =
                     new CopyOnWriteArrayList();
    public void run()
    {
        try {
            Thread.sleep(2000);
        }
        catch (InterruptedException e) {
            System.out.println("Child Thread"
                     + " going to add element");
        }
 
        // Child thread trying to add new
        // element in the Collection object
        l.add("D");
    }
 
    public static void main(String[] args)
        throws InterruptedException
    {
        l.add("A");
        l.add("B");
        l.add("c");
 
        // We create a child thread that is
        // going to modify ArrayList l.
        ConcurrentDemo t = new ConcurrentDemo();
        t.start();
 
        // Now we iterate through the ArrayList
        // and get exception.
        Iterator itr = l.iterator();
        while (itr.hasNext()) {
            String s = (String)itr.next();
            System.out.println(s);
            Thread.sleep(6000);
        }
        System.out.println(l);
    }
}

producción:

A
B
c