Zeit im Thread

Ich möchte verschiedene Sortieralgorithmen parallel testen, weshalb ich sie in threads laufen lasse

am schluss möchte ich jedoch wissen wie lange jeder thread bis zu seiner terminierung nur für sich aleine gebraucht hat

wie macht man so was?

Tolpan

mit

System.currentTimeMillis();

einfach vorher und nachher die aktuelle Zeit abfragen und die Differenz berechnen.

hmm entweder ich raff das nicht ...

wenn ich in einem thread das aufrufe bevor der algorithmus gestartet wird
liefert er mir doch die anzahl der millisek seit 1970 oder so,
wenn nun der scheduler zwischen threads umschaltet geht doch da zeit verloren , in der der thread nicht rechnen kann oder?

und wenn ich nach beendigung des threads wieder die zeit nehme dann sind doch genau diese (milli)sekunden zu viel für einen algorithmus berechnet worden oder?

alos so mein ich das

thread a1 startet
nehme zeit
starte algorithmus
-----------------
umschalt
-----------------
thread a2 startet
...
a1 kann hier nicht rechnen
-----------------
umschalt
-----------------
a1 beendet
messe zeit

gemessene Zeit = t(a1) + t(a2)

t(a2) zu viel

ich hoffe dass ich mich irre ^^

Michamab

Threads müssen auch nicht zwangsläufig nebenläufig abgearbeitet werden. Wenn du nur einen Prozessor hast, dann werden Threads auch mehr oder weniger sequentiell abgearbeitet, je nachdem wie der Scheduler die Rechenzeit vergibt. Deshalb verstehe ich nicht, warum du überhaupt die Sortieralgorithmen nebenläufig testen willst. Aber vielleicht hilft dir das hier weiter:

Anmerkung: Auch die Main-Methode ist ein Thread, deshalb sollte man es eigentlich so wie hier nicht machen. Finde ich aber übersichtlicher. Threads bringen einen großen Verwaltungsaufwand mit sich, deshalb sollte man sie nur mit Verstand benutzen.

import java.util.concurrent.Semaphore;

public class Warehouse
{
	static long timeA;
	static long timeB;

	// Semaphoren die signalisieren, dass
	// Thread A und Thread B fertig sind
	static Semaphore flagA = new Semaphore(0);
	static Semaphore flagB = new Semaphore(0);
}

public class A extends Warehouse implements Runnable
{
	public A() {}
	public void run()
	{
		timeA = System.currentTimeMillis();

		// tue irgendwas

		timeA = System.currentTimeMillis() - timeA;
		flagA.release();
	}
}

public class B extends Warehouse implements Runnable
{
	public B() {}
	public void run()
	{
		timeB = System.currentTimeMillis();

		// tue irgendwas

		timeB = System.currentTimeMillis() - timeB;
		flagB.release();
	}
}

import java.lang.Math;

public class ConcurrentTest extends Warehouse
{
	public static void main(String[] args)
	{
		Thread TA = new Thread(new A());
		Thread TB = new Thread(new B());

		// Threads starten
		TA.start();
		TB.start();

		// Auf Thread A und B warten
		flagA.acquireUninterruptibly();
		flagB.acquireUninterruptibly();

		System.out.println("Thread A: " + timeA + " ms");
		System.out.println("Thread B: " + timeB + " ms");
		System.out.println("Gesamtausführungszeit: " + 
				Math.max(timeB, timeB) + " ms");
	}
}

es funktioniert, aber was genau machst du da?

der code ist etwas kryptisch für mich, würdestdu mir den erklären?

nur das mit der gesamtzeit kann so nicht ganz stimmen:

Thread A: 3525 ms
Thread B: 793 ms
Gesamtausführungszeit: 793 ms

Dasd

Ich vermute, das liegt an Zeile 62. Die sollte man sich mal genauer anschauen.

Michamab

Richtig, hab mich leider in der entsprechenden Zeile verschrieben. Dort müsste eigentlich folgendes stehen:

Math.max(timeA, timeB)