Java-Thread-Instanziierung mit falschen Variablen

Question

Ich versuche Multithreading zu verwenden, um einen großen Block der Verarbeitung von Daten in kleinere Stücke zu zerlegen.
Das Problem, das ich habe, ist, dass meine Threads nicht gegen ihren angegebenen Teil des Datenbereichs laufen.

Zum Beispiel:

Thread-2 soll Bereich von 0 verarbeiten - 1000

faden 3 Bereich von 1001 verarbeitet werden soll - 2000

Als ich meine neuen nennen Threads Rücken an Rücken bekomme ich:

thread-2 = 0-1000

fade 3 = 0 - 1000

Wenn ich einen Thread sleep(3000) zwischen den beiden Fäden Anrufe hinzufügen i erhalten:

faden 2 = 0-1000

fade 3 = 0 - 2000

ich bin mir nicht sicher, was ich falsch mache und würde wirklich apprec Iate einige Anleitung.

Hinweis auf snippits unten, abgekürzt I den obigen Zahlen tatsächlichen Anrufbereich in Beispiel unten

ist

1.000.000 - 1.001.000 und 1.001.001 - 1.002.000

Schnipsel aus dem Hauptverfahren Detaillierung Faden Call:

 try { 
     int start = 1000000; 
     int end = 1001000; 
     new Thread(new MyThread(start, end, PUBLIC_INVALID_LIST)).start(); 
     Thread.sleep(3000); 
     start = 1001001; 
     end = 1002000; 
     new Thread(new MyThread(start, end, PUBLIC_INVALID_LIST)).start(); 
    } catch (InterruptedException ex) { 
     Thread.currentThread().interrupt(); 
    } 

Snippet von MyThread das ThemaerstrecktDiese Details, wie ich params vom Hauptverfahren bis zur run() Methode bin vorbei:

//variables to pass from constructor to run() 
private int startIndex; 
private int endIndex; 
private ArrayList PUBLIC_INVALID_LIST; 

MyThread(int startIndex, int endIndex, ArrayList PUBLIC_INVALID_LIST) { 

    this.startIndex = startIndex; 
    this.endIndex = endIndex; 
    this.PUBLIC_INVALID_LIST = PUBLIC_INVALID_LIST; 

}//end of initializer 

public void run() { 

Answer 1

immer noch nicht sicher, was das Problem mit den Variablen war passieren, aber ich bekam einen alternativen Pass in Methode int mit zu arbeiten, []

int sizeSet = (max /100000) + 1;//max is highest path_id value 
    int[] start_range = new int[sizeSet]; 
    int[] end_range = new int[sizeSet]; 
    start_range[0] = 1;//first possible path_id 
    end_range[0] = 100000;//end point of first possible range 
    int rangeIndex = 1;//create counter for while loop 
    while(rangeIndex < sizeSet){ 
     start_range[rangeIndex] = start_range[rangeIndex - 1] + 100000; 
     end_range[rangeIndex] = end_range[rangeIndex - 1] + 100000; 
     ++ rangeIndex; 
    }//end range setting while block 
    rangeIndex = 0;//reset index counter 
    while(rangeIndex < sizeSet){ 
     new Thread(new MyThread(start_range[rangeIndex], end_range[rangeIndex], PUBLIC_INVALID_LIST)).start(); 
     ++ rangeIndex; 
    }