Wie kann ich auf diese Liste zugreifen und auch Thread-sicher sein?

Question

Mein Haupt spawnt 2 Threads und beide müssen auf die gleiche Liste zugreifen. Ich bin nicht sicher, was der beste Weg ist, dies zu tun. Hier ist, was ich habe, aber ich laufe immer noch in concurrentModificationException.

class Parent { 
    private List<String> data; 

    public List<String> getData() { 
     return data; 
    } 

    public static void main(String args[]) { 
     Parent p = new Parent(); 
     p.start(); 
    } 

    public void start() { 
     Thread a = new Thread(new A(this)).start(); 
     Thread b = new Thread(new B(this)).start(); 
    } 

    public A implements Runnable { 
     private Parent parent; 

     public A(Parent p) { 
     parent = p; 
     } 

     public void run() { 
     while (true) { 
      parent.getData().add("data"); 
     } 
     } 
    } 

    public B implements Runnable { 
     private Parent parent; 

     public B(Parent p) { 
     parent = p; 
     } 

     public void run() { 
     Iterator<String> i = parent.getData().iterator(); 
     while(i.hasNext()) { 
      // do more stuff with i 
      i.remove(); 
     } 
     } 
    } 
} 

meine A Klasse ist im Grunde ein Produzent von Daten und B ist der Verbraucher. Ich akzeptiere die Möglichkeit, dass ich das falsch mache. So ist jede Hilfe willkommen. Ich muss nur sicher in der Lage sein, zu einer Liste von einem Thread hinzuzufügen und ein Element aus der Liste von einem anderen Thread zu entfernen. Danke im Voraus.

Answer 1

Nun, für einen Hersteller/Verbraucher würde ich LinkedBlockingQueue oder ConcurrentLinkedQueue empfehlen. Dies behandelt gleichzeitige Lese- und Schreibvorgänge (oder Push/Abfragen in diesem Fall).

Wahrscheinlich möchten Sie, dass Ihr Consumer läuft, bis einige Shutdown-Bedingungen an ihn gesendet werden. Wenn Sie eine Sperrwarteschlange verwenden, bedeutet dies, dass Sie ein Element in der Warteschlange senden möchten, das angibt, dass der Verbraucher den Konsum stoppen soll. Dies wäre eine blockierende Warteschlangenimplementierung mit einem Herunterfahren.

public enum QueueItemType { 
     CONSUMABLE, 
     SHUTDOWN 
    } 

    public class QueueItem { 
     public final QueueItemType type; 
     public final String payload; 

     public QueueItem(QueueItemType type, String payload) { 
     this.type = type; 
     this.payload = payload; 
     } 
    } 

    public class B implements Runnable { 
     private Parent parent; 

     public B(Parent p) { 
     parent = p; 
     } 

     public void run() { 
     while(true) { 
      QueueItem data = parent.getData().poll(); 
      if (data.type == QueueItemType.SHUTDOWN) { 
       break; 
      } else { 
       // do more stuff with data.payload 
      } 
     } 
     } 
    } 

Hinweis, dass es keine Nullprüfung für eine poll Ergebnis der Blockierung Warteschlange. Dies liegt daran, dass blockierende Warteschlangen definitionsgemäß den laufenden Thread blockieren, bis etwas vorhanden ist.

Wenn Sie einen Verbraucher bevorzugen, der nicht mit dem Hersteller konkurriert, müssen Sie regelmäßig abfragen und den Consumer-Thread ausschlafen. Hier ist ein Beispiel, wenn Sie die ConcurrentLinkedQueue verwendet:

public class B implements Runnable { 
     private Parent parent; 

     public B(Parent p) { 
     parent = p; 
     } 

     public void run() { 
     while(parent.isStillRunning()) { 
      String data = parent.getData().poll(); 
      if (data != null) { 
       // do more stuff with data 
      } else { 
       Thread.sleep(10 /*10 ms, but you can make this whatever poll interval you want*/); 
      } 
     } 
     } 
    } 

Answer 2

Die am wenigsten wirkungsvolle Veränderung, könnte eine Setter zu verwenden, die synchronisiert ist. Auf diese Weise müsste ein Thread warten, bis die Sperre aufgehoben wird, bevor die Sammlung hinzugefügt werden kann.