Thread-Arrays

[sup?]

Hi,
ich hab folgende Aufgabe:
Ändern Sie das Programm so, dass es möglich ist, die Threadanzahl über eine lokale Variable
festzulegen! (Hinweis: Es wird ein Thread-Array und eine Schleife benötigt).
Kann mir jemand erklären wie man das macht oder n Link für n passendes Tutorial schicken?

Hier mal die MainKlasse:

package edu.hm.winf.tutorium.uebung7;
/**
 * Testklasse für synchronisierten und nicht synchronisierten Zugriff
 */
class CountTest
{
	public static void main(String[] args)
	{
		CounterObject c = new CounterObject();
		final int maxCount = 1000; // Jeder Thread soll 1000 mal um 1 erhöhen
		final int maxThread = 3;
		
		
		/*
		 * Wir starten drei nebenläufige Threads und warten auf ihr 
		 * Ende
		 */
		Thread t1 = new CountThread1(c, maxCount);
		Thread t2 = new CountThread1(c, maxCount);
		Thread t3 = new CountThread1(c, maxCount);

		System.out.println("Test ohne Synchronisation geht jetzt los ...");
				
		try {
			
			// Threads starten
			t1.start();
			t2.start();
			t3.start();
			// Warten auf das Ende der Threads
			t1.join();
			t2.join();
			t3.join();
			
		}
		catch (InterruptedException e) {
			System.out.println("Thread interrupted");
		}
		finally {
			System.out.println("Counter am Ende des Tests, Wert sollte "+maxCount*maxThread+" sein, " 
					+ "berechneter Wert " + c.get());
			System.out.println("Test ohne Synchronisation ist zu Ende");
		}			
		
		/*
		 * Wir starten drei nebenläufige Threads und warten auf ihr 
		 * Ende
		 */
		 
		c.set(0); // Zähler auf 0 setzen
		
		t1 = new CountThread2(c, maxCount);
		t2 = new CountThread2(c, maxCount);
		t3 = new CountThread2(c, maxCount);

		System.out.println("Test mit Synchronisation geht jetzt los ...");
				
		try {
			
			// Threads starten
			t1.start();
			t2.start();
			t3.start();
			
			// Warten auf das Ende der Threads
			t1.join();
			t2.join();
			t3.join();
		}
		catch (InterruptedException e) {
			System.out.println("Thread interrupted");
		}
		finally {
			System.out.println("Counter am Ende des Tests, Wert sollte "+maxCount*maxThread+" sein, " 
					+ "berechneter Wert " + c.get());
			System.out.println("Test mit Synchronisation ist zu Ende");
		}			
	}
}

 

[HoaX]

Google halt man nach Java und Schleife sowie nach Java und Array. Wenn du das dann verstanden hast ist die Aufgabe oben ein klacks.
Zeig doch mal was du schon geschafft hast und womit du konkret Probleme bei der Fragestellung hast.

 

[njans]

        Thread t1 = new CountThread1(c, maxCount);
        Thread t2 = new CountThread1(c, maxCount);
        Thread t3 = new CountThread1(c, maxCount);

Da erstellst du Threads manuell. Was deine Aufgabe ist, wäre wohl sowas:

for (int currentThread = 0; currentThread < CONSTANT; ++currentThread)
{
  threadArray[currentThread] = new CountThread1(c, maxCount);
}

Wobei die CONSTANT der Wert ist, der die Anzahl der Threads bestimmt

 

[sup?]

Das hab ich bisher:

int not = 10;
		
		/*
		 * Wir starten drei nebenläufige Threads und warten auf ihr 
		 * Ende
		 */
		
		Thread arr[] = new Thread[not];
		for(int i=0; i<not; i++){
			Thread t = new CountThread1(c, maxCount);
			arr[i] = t;
		}

Wie führe ich jetzt t1.start etc aus?^^

Edit:
ah wieder mit for schleife ? ^^

 

[sup?]

class CountTest
{
	public static void main(String[] args)
	{
		CounterObject c = new CounterObject();
		final int maxCount = 1000; // Jeder Thread soll 1000 mal um 1 erhöhen
		final int maxThread = 3;
		int not = 10;
		
		/*
		 * Wir starten drei nebenläufige Threads und warten auf ihr 
		 * Ende
		 */
		
		Thread arr[] = new Thread[not];
		for(int i=0; i<not; i++){
			Thread t = new CountThread1(c, maxCount);
			arr[i] = t;
		}
		

		System.out.println("Test ohne Synchronisation geht jetzt los ...");
				
		try {
			
			
			for(int i=0; i<not; i++){
				arr[i].start();
			}
			for(int i=0; i<not; i++){
				arr[i].join();
			}
		}
		catch (InterruptedException e) {
			System.out.println("Thread interrupted");
		}
		finally {
			System.out.println("Counter am Ende des Tests, Wert sollte "+maxCount*maxThread+" sein, " 
					+ "berechneter Wert " + c.get());
			System.out.println("Test ohne Synchronisation ist zu Ende");
		}			
		
		/*
		 * Wir starten drei nebenläufige Threads und warten auf ihr 
		 * Ende
		 */
		 
		c.set(0); // Zähler auf 0 setzen
		
		Thread arr2[] = new Thread[not];
		for(int i=0; i<not; i++){
			Thread t = new CountThread2(c, maxCount);
			arr2[i] = t;
		}

		System.out.println("Test mit Synchronisation geht jetzt los ...");
				
		try {
			for(int i=0; i<not; i++){
				arr2[i].start();
			}
			for(int i=0; i<not; i++){
				arr2[i].join();
			}
		}
		catch (InterruptedException e) {
			System.out.println("Thread interrupted");
		}
		finally {
			System.out.println("Counter am Ende des Tests, Wert sollte "+maxCount*maxThread+" sein, " 
					+ "berechneter Wert " + c.get());
			System.out.println("Test mit Synchronisation ist zu Ende");
		}			
	}
}

habs gschafft denk ich. vielen dank !

 

[SlaterB]

wenn schon Kommentare im Code sind, dann auch um Richtigkeit bemühen,
2x steht 'Wir starten drei nebenläufige Threads', einmal sind es allerdings 10, das andere mal ist der Hinweis komplett fehl am Platz

die schöne Variable
maxThread = 3;
wird nicht verwendet, stattdessen das hässliche 'not', was immer das heißen soll, number of threads?

 

[njans]

ja das sollte so gehen

 

[Landei]

In den meisten Fällen brauchst du keinen Schleifenindex:

//anstatt...
for(int i=0; i<not; i++){
   arr[i].start();
}

//...besser...
for(Thread t : arr){
   t.start();
}