Zwei Threads lesen die gleiche Liste aber von verschiedenen Enden

Question

Ich habe eine Liste, ich muss die Liste von zwei Threads durchlaufen. Eine Lesung von oben nach unten und eine andere von unten nach oben. Und wenn sie sich schneiden, sollte das Lesen aufhören.

Zum Iterieren über die Liste kann ich ListIterator verwenden, aber ich bin nicht in der Lage zu denken, wie diese Threads aus derselben Liste lesen werden?

Answer 1

Da die Threads nur gelesen werden, ist es nicht erforderlich, eine Thread-sichere Version der Liste zu verwenden.

Um sicherzustellen, dass die Threads nicht mehr lesen, wenn sie sich schneiden, müssen Sie sie synchronisieren. Bevor Sie also ein anderes Element lesen, sollten Sie prüfen, ob dieses Objekt verfügbar ist. Eine naive Möglichkeit, dies zu implementieren, besteht darin, den aktuellen Index in jedem Thread zu speichern und dem anderen Thread Zugriff auf diesen Index zu gewähren (stellen Sie sicher, dass dieser Index synchronisiert wird). Dies würde jedoch zu viel Overhead führen.

Eine bessere Idee ist es, in Batches zu arbeiten. Unterteilen Sie die Liste in Abschnitte von beispielsweise 16 Elementen. Dann können die Threads die gesamte Charge lesen, bevor sie nach einer Kreuzung suchen müssen.

Answer 2

Sie können die Liste partitionieren, die ein Thread von 0 bis zur Hälfte lesen wird und die zweite wird die Hälfte + 1 für die letzte lesen.

class PrintList implements Runnable{ 

    private List list = new ArrayList(); 
    public PrintList(List list){ 
     this.list = list; 
    } 


    @Override 
    public void run() { 
    if(Thread.currentThread().getName() != null && Thread.currentThread().getName().equalsIgnoreCase("thread1")){ 
     int mid =list.size()/2; 
     for(int i = 0; i< mid;i++){ 
      // System.out.println("Thread 1 "+list.get(i)); 
     } 
    }else if(Thread.currentThread().getName() != null && Thread.currentThread().getName().equalsIgnoreCase("thread2")){ 

     for(int i = mid; i<list.size(); i++){ 
      //System.out.println("Thread 2 "+list.get(i)); 
     } 
    } 
    } 
} 

Answer 3

Es gibt eine einfache Möglichkeit, dieses Problem zu lösen, wenn Sie berücksichtigen, dass die Gesamtzahl der Elemente von Thread A verarbeitet und die Summe durch Gewinde B verarbeitet Elemente werden am Ende auf die Menge der Elemente in der gleich Liste.

Wenn Sie also einen Zähler haben, der jedes Mal dekrementiert, wenn ein Thread das nächste Element verarbeiten möchte, wissen Sie, dass Sie fertig sind, sobald der Zähler Null erreicht.

public class MyThreadSyncer { 
    protected final AtomicInteger elementCount; 

    public MyThreadSyncer(final Collection c) { 
    elementCount = new AtomicInteger(c.size()); 
    } 

    public boolean canProcessNext() { 
    return (this.elementCount.decrementAndGet() >= 0); 
    } 
} 

diese Klasse Mit jedem Thread über einen eigenen Zähler setzt (Thread A bei 0, Gewinden B bei Größe-1) und prüft dann wie folgt aus:

if (this.threadSyncer.canProcessNext()) { 
    this.theTasks[this.myPosition].process(); 

    this.myPosition += 1; // this line in thread A 
    this.myPosition -= 1; // this line in thread B 
}