Restzeit berechnen (Kopiervorgang)

[Betomax]

Hallo miteinander,

ich habe mal eine Frage zu diesem Codeschnippsel:

public class Test {

	public static void main(String[] args) throws InterruptedException {

		long currentTimeMillis = System.currentTimeMillis();

		for (int i = 100; i < 1000; i += 100) {
			System.out
					.println("Test.main() "
							+ getCalculateRemainingTimeInSec(currentTimeMillis,
									1000, i));
			Thread.sleep(1000);
		}
	}

	private static long getCalculateRemainingTimeInSec(long startTime,
			long sourceLenght, long destLenght) {

		long elapsedTime = System.currentTimeMillis() - startTime;

		float sum = (float) ((((destLenght * 100) / sourceLenght)) / 100.0);

		long totalMillis = (long) (elapsedTime / sum);

		long remainingMillis = totalMillis - elapsedTime;
		int remainingSeconds = (int) remainingMillis / 1000;
		return remainingSeconds;

	}
}

Wie kann ich dafür sorgen, dass die mögliche Restzeit korrekt berechnet wird.
Gibt es eine Formel um diese zu Berechnen?

Im Code funktioniert es zum Ende hin. Allerdings hätte ich erwartet das er mir solche Ausgabe produziert:

Test.main() 0
Test.main() 9
Test.main() 8
Test.main() 7
Test.main() 6
Test.main() 4
Test.main() 3
Test.main() 2
Test.main() 1

aber diese Ausgabe kommt

Test.main() 0
Test.main() 4
Test.main() 4
Test.main() 4
Test.main() 4
Test.main() 3
Test.main() 2
Test.main() 1
Test.main() 0

 

[kaoZ]

letzten endes musst du doch einfach nur die zeit vor deinem Vorgang loggen, und nach deinem Vorgang loggen und dann dementsprechend die differenz zwischen diesen Zeiten berechnen.

Das hier führt z.B :

public class Foo {

	public static void main(String[] args) {
		
		long start = System.currentTimeMillis();
		
		for (int i = 0; i < 5; i++) {
			System.out.print("a");
			try {
				Thread.sleep(1000);
				System.out.println(System.currentTimeMillis() - start);
			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}
		
		long end = System.currentTimeMillis();
		
		System.out.println(start + " " + end);
		System.out.println((end - start) / 1000 % 60 + " sekunden");
		
	}
}

führt zu folgender ausgabe :

a1000
a2000
a3000
a4000
a5000
1405953759638 1405953764638
5 sekunden

du führst deine Berechnungen alle durch bevor du den Thread schlafen legst

 

[Betomax]

Hallo kaoZ,

vielleicht sollte ich erwähnen, dass ich eine Berechnung während eines Kopiervorgangs haben möchte.
Wieviel Zeit noch vertreichen wird, bis der Kopiervorgang fertig ist.
Natürlich ist solch eine Berechnung nicht immer 100% genau.

Aber dein Vorschlag würde dann nicht passen.

Ich habe nur dieses Beispiel erstellt, damit ich ein Kopiervorgang simuliere und wo ich davon ausgehe das die Daten mit 100 MB/Sek geschrieben werden.

Grüße

 

[kaoZ]

Also möchtest du die noch zu erwartenden Wartezeit berechnen bis alle Kopiervorgänge abgeschlossen sind =?

 

[Betomax]

Ja, so kann man das auch sagen.

Alle muss nicht zwingend sein, würde es nur zu verkomplizieren. Aber bei einer Datei würde schon ausreichen.

Bin davon ausgegangen das meine Methode, dies abbildet, aber dies tut es wohl nicht zu 100%.
Wenn dann nur zur hälfte.

 

[kaoZ]

Das Augenscheinliche Problem ist hier das die Endzeit immer wieder neu belegt wird innerhalb der schleife

Demnach führt dies zu ungewollten ausgaben, kleinen moment eben ^^

so , doch irgendwie komplizierter als erwartet xD

schau mal ob du damit was anfangen kannst, und ob das ungefähr das ist worauf du hinaus möchtest.

public class Foo {

	public static void main(String[] args) {

		int remaining = 10;
		int count = 0;
		
		long buffer = 0;
		
		for(; count < remaining; count++){

			long start = System.currentTimeMillis();
			
			System.out.println("Hallo welt");
					
			long end = System.currentTimeMillis();
			
			if(end - start < 1L){
				buffer = 1000;
			}


			System.out.println(calculateRemainingTime(buffer, remaining - count));
			

			try {
				Thread.sleep(1000);
			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}
		
		
	}
	
	public static long calculateRun(long start, long end){
		return end - start;
	}
	
	public static String calculateRemainingTime(long time, int remaining){
		return String.format("%d sekunden verbleibend", (time / 1000 % 60) * remaining);
	}
	
}

führt zu folgender Ausgabe :

Hallo welt
10 sekunden verbleibend
Hallo welt
9 sekunden verbleibend
Hallo welt
8 sekunden verbleibend
Hallo welt
7 sekunden verbleibend
Hallo welt
6 sekunden verbleibend
Hallo welt
5 sekunden verbleibend
Hallo welt
4 sekunden verbleibend
Hallo welt
3 sekunden verbleibend
Hallo welt
2 sekunden verbleibend
Hallo welt
1 sekunden verbleibend

 

[Betomax]

Hallo Koaz.

Ja das es zu dieser Ausgabe führt ist ja verständlich da du von der Gesamtsumme(remaining) die Menge(counter) abziehst.
Aber wenn du z.B 989 MB hast und die Schreibgeschwindigkeit zwischen 40-55 MB/sec ist,
müsste bei jeden durchlauf dies berechnet werden.

1) Wie schnell ist die Schreibgeschwindigkeit
2) Wieviel schon geschrieben(kopiert) wurde
3) Wieviel insgesamt zu schreiben ist

Allerdings vermute ich, das ich was in meiner Rechnung vergessen haben.

Viele Grüße

Betomax

 

[Thallius]

Was Du da rechnest ist irgendwie vollkommen verkehrt.

Dein sum ist ja keine Summe sondern der prozentuale Anteil der bisher transportiert wurde. Also 0.1,0.2,0.3... Dadurch teilst du die verstrichene Zeit und glaubst nun das die noch verbleibende Zeit sich aus der subtraktion mit der verstrichenen Zeit ergibt?

Wenn schon, dann must du die verstrichene Zeit mit dem Kompliment von sum multiplizieren also (1-sum)*elapsedTime. Weiterhin solltest du besser durchgehend mit float rechnen und nur den Rückgabewert dann in ein int wandeln. Sonst verhaut man sich richtig schnell mal.

Gruß

Claus