Come dimostrare che l'arraylist non è thread-safe con un test?

Question

Nella nostra applicazione abbiamo ottenuto un'eccezione ArrayIndexOutOfBounds sull'operazione ArrayList.add(Object o). La spiegazione più ovvia è la sicurezza del thread, ma non sono stato in grado di ricreare gli eventi. Ho provato a creare due thread. In uno sto aggiungendo elementi, nell'altro li sto rimuovendo (o cancellando l'array), ma non ho ottenuto l'eccezione per la seconda volta. Voglio dire, è ovvio che può succedere guardando la fonte di ArrayList, ma sarebbe bello poterlo dimostrare.

Ho corso questa prova per un bel po 'di tempo, senza alcuna eccezione:

public class Test { 
static ArrayList a = new ArrayList(); 

public static void main(String[] args) throws Exception { 
    Thread t1 = new Thread() { 
     public void run() { 
      while (true) { 
       if (a.size() > 0) 
        a.remove(0); 
      } 
     } 
    }; 

    Thread t2 = new Thread() { 
     public void run() { 
      while (true) { 
       a.add(new Object()); 
      } 
     } 
    }; 

    t2.start(); 
    Thread.sleep(100); 
    t1.start(); 
} 
} 

Answer 1

Grazie per commentare da isnot2bad ho trovato un problema nella mia ipotesi. Il problema è con gli aggiunti simultanei, non con l'aggiunta/rimozione. sono stato in grado di creare un test in mancanza:

static ArrayList a = new ArrayList(1); 

public static void main(String[] args) throws Exception { 
    Thread t1 = new Thread() { 
     public void run() { 
      while (true) { 
       a.add(new Object()); 
      } 
     } 
    }; 

    Thread t2 = new Thread() { 
     public void run() { 
      while (true) { 
       a = new ArrayList(1); 
       a.add(new Object()); 
       a.add(new Object()); 
      } 
     } 
    }; 

    t2.start(); 
    Thread.sleep(100); 
    t1.start(); 
} 

Sulla linea con l'aggiunta al primo thread, sto ottenendo questo:

Exception in thread "Thread-0" java.lang.ArrayIndexOutOfBoundsException: 2 

:)

Answer 2

io sono in grado per riprodurre il problema semplicemente aggiungendo più thread di adder.

Answer 3

Fare in modo che il thread del consumatore dorma molto meno del sonno del produttore, ad es. 20 ms anziché 100 ms. In questo modo le probabilità che l'eccezione venga lanciata sono molto più grandi.

Answer 4

Può essere difficile osservare qualsiasi errore con il codice dato perché in realtà non si controlla cosa è memorizzato nell'elenco. Non posso dire che sia impossibile ottenere uno ArrayIndexOutOfBoundsException ma sarà molto raro perché è possibile ottenerlo solo quando l'array viene ridimensionato e viene ridimensionato molto di rado.

Se si controlla che gli oggetti che si rimuovono non siano duplicati è molto più probabile vedere un comportamento imprevisto: si aggiungono solo nuovi oggetti, quindi il thread che rimuove non dovrebbe mai vedere lo stesso oggetto due volte, giusto? Non così:

import java.util.*; 
public class Test { 
    static ArrayList a = new ArrayList(); 

    public static void main(String[] args) throws Exception { 
     Thread t1 = new Thread() { 
      public void run() { 
       Object x = null; 
       while (true) { 
        if (a.size() > 0) { 
         Object y = a.remove(0); 
         if (x == y) System.out.println("Duplicate!"); 
         x = y; 
        } 
       } 
      } 
     }; 

     Thread t2 = new Thread() { 
      public void run() { 
       while (true) { 
        a.add(new Object()); 
       } 
      } 
     }; 

     t2.start(); 
     Thread.sleep(100); 
     t1.start(); 
    } 
} 

Ciò accade quando viene aggiunto un oggetto durante la chiamata System.arrayCopy: elementData[--size] = null imposta l'indice di matrice sbagliato null perché size non ha più il valore che aveva all'inizio del metodo.