Threads

[Malcolm]

Hallo,

hab folgendes Problem. Es geht darum ein Array mit z.B. einer Größe von 1000000 zu befüllen. Drei verschiedene Threads sollen jeweils drei verschiedene Werte in das Array schreiben. Es geht darum zu erkennen ob und falls ja wie oft sich die einzelnen Threads dabei abwechseln ihre Daten in das Array zu schreiben.

Bei meiner Version tritt teilweise folgender Laufzeitfehler auf ==>

java.lang.ArrayIndexOutOfBoundsException: 1000000
at Feld.setWert(Umschalten.java:26)
at FeldSchreiber.run(Umschalten.java:62)
java.lang.ArrayIndexOutOfBoundsException: 1000000
at Feld.setWert(Umschalten.java:26)
at FeldSchreiber.run(Umschalten.java:62)
java.lang.ArrayIndexOutOfBoundsException: 1000000
at Feld.setWert(Umschalten.java:26)
at FeldSchreiber.run(Umschalten.java:62)

Kann mir einer sagen warum die Größe meines Feldes teilweise nicht ausreicht bzw. wie ich synchronized plazieren muss das die Parallelität so wenig wie möglich eingeschränkt wird, und troztdem gewährleistet ist das weder Werte verloren gehen noch das mein Feld überläuft.

class Feld 
{
  private int index;	
  private int size;	
  private int[] feld;	
   
  public Feld(int size)
  {
  	this.index = 0;
  	this.size = size;
  	feld = new int[size];
  }
  
  public int getSize()
  {
  	return size;
  }
  
  public int getIndex()
  {
  	return index;
  }
   
  public void setWert(int wert)
  {
  	feld[index] = wert;
    index++;
  }
  
  public void ausgeben()
  {
    int einsen=0, zweien=0, dreien=0; 
  
    for(int i=0; i<size; i++)
    {
      if(feld[i] == 1) {einsen++;}
      if(feld[i] == 2) {zweien++;}
      if(feld[i] == 3) {dreien++;}
    }
    
    System.out.println(einsen);
    System.out.println(zweien);
    System.out.println(dreien);
  }
}

class FeldSchreiber extends Thread
{
	Feld feld;
	int wert;
	
	public FeldSchreiber(Feld feld, int wert)
	{
		this.feld = feld;
	    this.wert = wert;
	}
	
	public void run()
	{
		for(int i=feld.getIndex(); i<feld.getSize(); i++)
		{
			feld.setWert(wert);	
		}
	}
}

public class Umschalten 
{
	public static void main(String[]args)
	{
		Feld feld = new Feld(1000000);
		
		FeldSchreiber t1 = new FeldSchreiber(feld,1);
		FeldSchreiber t2 = new FeldSchreiber(feld,2);
		FeldSchreiber t3 = new FeldSchreiber(feld,3);
		
		t1.start();
		t2.start();
		t3.start();
		
		try 
		{
			t1.join();
	  	    t2.join();
	  	    t3.join();
		} 
		catch (InterruptedException e) 
		{
	  	}

		feld.ausgeben();
	}
}

 

[Wildcard]

Kann ja auch gar nicht gehen.
Drei Threads die in einer for-schleife über die gesamte Array länge gehen,
rufen die setWert() methode auf. Diese erhöt für jeden Wert den Index.
Wenn jeder Thread seine aufgabe zu 1/3 erledigt hat ist das Array zu ende.

  public void run() 
   { 
      for(int i=feld.getIndex(); i<feld.getSize()/3; i++) 
      { 
         feld.setWert(wert);    
      } 
   }

 

[foobar]

Da die run-Methode nicht synchronisiert ist, kann es sein daß ein Thread feld.getSize() aufruft und dann unterbrochen wird. Wenn dieser Thread dann wieder etwas Rechenzeit bekommt, hat ein anderer Thread möglicherweise setWert() aufgerufen und den Index inkrementtiert. Dadurch schreibt der erste Thread über den maximalen Index hinaus, was zu einer IndexOutofBoundsException führt.

[Edit: Mist zu spät ]

 

[foobar]

Wenn jeder Thread seine aufgabe zu 1/3 erledigt hat ist das Array zu ende.

Wobei nicht gewährleistet ist, daß jeder Thread die selbe Rechenzeit zugewiesen bekommt, wie die anderen Threads.

 

[Wildcard]

Wobei nicht gewährleistet ist, daß jeder Thread die selbe Rechenzeit zugewiesen bekommt, wie die anderen Threads.

War das nicht genau Sinn der Übung?

Wenn jeder Thread seine aufgabe zu 1/3 erledigt hat ist das Array zu ende.

ist natürlich nicht wörtlich zu nehmen, kann man nicht vorhersagen.
Ging mir nur darum zu zeigen dass das Array nicht groß genug für 3 Threads ist, also
entweder den Bereich jedes Einzelnen einschränken, oder terminieren wenn das Array voll ist.