Geschätze Zeit implementieren

[Kababär]

Hi,

ich suche nach einer Möglichkeit, um die verbleibende Zeit bzw geschätzte Zeit separat und stets aktuell in einem JavaFX Label darzustellen.
Wie könnte ich so etwas realisieren?

 

[Thallius]

Die geschätzte Zeit für was? Bis die Welt untergeht?

 

[StarSheriff]

Fortschritt im allgemeinen stellst du mit ner ProgressBar dar:

http://docs.oracle.com/javafx/2/ui_controls/progress.htm

 

[Kababär]

Die geschätzte Zeit für was? Bis die Welt untergeht?

Nein, wie lange es dauert bis Jesus wieder aufersteht.

Fortschritt im allgemeinen stellst du mit ner ProgressBar dar

Ist schon implementiert. Ich hätte aber gerne noch eine ungefähre Zeit. Gibt es eine Approximation für die Laufzeit eines Algorithmus oder generell einer Methode in reeller Zeit?

 

[Thallius]

Nein natürlich nicht. Das must du dir schon selber ausrechnen. Du misst einfach wie lange ein Schleifendurchlauf dauert und rechnest das dann hoch...

 

[Kababär]

Wäre Reflection dazu eine gute Lösung?
Denn der empirische Wert würde ja verfälscht bzw. viel zu gering ausfallen, wenn ich mehrere Schleifen habe, die nicht verschachtelt, sondern nacheinander auftreten.

 

[Thallius]

Ich habe keine Ahnung was jetzt Reflections damit zu tun haben sollen.

Wenn Du mehrere Schleifen, also mehrere Schritte hast, dann würde ich das dem User auch so vermitteln. Also einfach ein 1/3 oder so hinter die Progressbar und dann zählt die halt so oft runter bis alle 3 Schritte erledigt sind.

 

[Kababär]

Naja ich könnte ja die Methoden aufrufen und die Zeit messen. Aber das hätte zur Folge dass das Programm doppelt so lang bräuchte.

Dadurch entsteht ja auch eine Verzerrung unter der Annahme, dass jede Schleife in ihrer Laufzeit variiert.

Ich werde mir was einfallen lassen. Aber danke für die Ansätze 🙂

 

[JStein52]

Naja ich könnte ja die Methoden aufrufen und die Zeit messen. Aber das hätte zur Folge dass das Programm doppelt so lang bräuchte.

Du hast also keine Schleife sondern eine Methode die etwas längliches ausführt und willst wissen wie lange das denn nun dauern wird und wieviel davon du schon erledigt hast oder wie ?

 

[Kababär]

Du hast also keine Schleife sondern eine Methode die etwas längliches ausführt und willst wissen wie lange das denn nun dauern wird und wieviel davon du schon erledigt hast oder wie ?

Ich habe viele Methoden und ganz schön viele Schleifen (circa 30) .
Aber ja der Rest stimmt 🙂


edit: Wie wäre es Tests für die einzelnen Methoden oder Schleifen zu schreiben (ca. 1000 Tests bzw. Durchläufe) und das empirische Mittel zu berechnen und dieses als Erwartungswert für die Appromixation zu verwenden?

 

[InfectedBytes]

Das wird nichts nützen, da du dann nur weißt wie es auf deinem Rechner läuft und unter den Voraussetzungen die du bei den Test hattest.
Auf einem anderen Rechner oder sobald du vielleicht noch nen weiteres Programm laufen hast, ist das ganze wieder unbrauchbar. Außerdem kann es sogar unter exakt den gleichen Ausgangsbedingungen dennoch zu unterschieden kommen.

 

[Kababär]

Stimmt. Habe ich nicht bedacht..
Danke für die Zurechtstutzung.

 

[JStein52]

Aber wenn es dir darum geht zu wissen wie lange ein Schleifendurchlauf dauert dann mach es doch wie oben schon mal gesagt: du misst laufend wie lange jeder einzelne Durchlauf dauert und rechnest daraus immer wieder hoch wie lange die restlichen Durchläufe noch dauern.

 

[Tobse]

Ich habe sowas mal (mit Unterstützung des NetBeans GUI Builders) programmiert:

Ist eine Klasse ProgressFrame, welche eine Progressbar und ein JLabel darstellt. Bei jedem Aufruf von setValue() wird der Fortschritt berechnet und eine Zeitabschätzung angezeigt. Das ist natürlich bei weitem nicht so akkurat wie eine Abschätzung, welche auf einen speziellen Algorithmus ausgelegt ist.
Und das GUI Layout ist wie gesagt mit dem NetBeans GUI Builder gemacht.

Verwendungsbeispiel:

ProgressFrame pF = new ProgressFrame("Berechnet Zeitpunkt des Weltuntergangs....");
for (int i = 0;i < 100;i++) {
    pF.setValue(i);
    Thread.sleep(1000);
}

Das sollte dann die 1m 40s relativ präzise runterzählen.

import java.util.Date;

public class ProgressFrame extends javax.swing.JFrame {

    private Date lastChange = null;
    private int value = 0;
    private int lastValue = 0;
    private int maximum;
  
    public ProgressFrame(String title) {
        initComponents();
        setTitle(title);
        progressBar.setStringPainted(false);
        progressBar.setMinimum(0);
        progressBar.setMaximum(100);
        pack();
        setLocationRelativeTo(null);
    }

    public void setValue(int value)
    {
        progressBar.setValue(value);
        this.value = value;
        if (lastChange == null)
        {
            lastChange = new Date();
        }
        Date now = new Date();
        long diff = now.getTime() - lastChange.getTime();
        if (diff >= 1000)
        {   
            int dx = (int) (((new Date()).getTime() - lastChange.getTime()));
            float change = (float) (value - lastValue) / (float) dx;
            etaLabel.setText(
                formatAsETA((int) (((float) (maximum - value) / change) / 1000))
                + " remaining"
            );
            this.lastValue = value;
            lastChange = now;
        }
    }
    public void setMinimum(int min)
    {
        progressBar.setMinimum(min);
    }
    public void setMaximum(int max)
    {
        progressBar.setMaximum(max);
        maximum = max;
    }
    public void setAction(String action)
    {
        currentActionLabel.setText(action);
    }
    public void setIndeterminate(boolean is)
    {
        progressBar.setIndeterminate(is);
        if (is)
        {
            etaLabel.setText("");
        }
        else
        {
            etaLabel.setText(
                "estimating..."
            );
        }
    }
  
    private static String formatAsETA(int nSeconds)
    {
        int minutes = 0;
        while (nSeconds >= 60)
        {
            nSeconds -= 60;
            minutes++;
        }
        if (minutes != 0)
        {
            return minutes + "m " + nSeconds + "s";
        }
        else
        {
            return nSeconds + "s";
        }
    }
  
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        currentActionLabel = new javax.swing.JLabel();
        etaLabel = new javax.swing.JLabel();
        progressBar = new javax.swing.JProgressBar();

        setDefaultCloseOperation(javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE);
        setResizable(false);

        currentActionLabel.setText("-");

        etaLabel.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
        etaLabel.setText("estimating...");

        progressBar.setToolTipText("");
        progressBar.setValue(30);

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                    .addComponent(progressBar, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                    .addGroup(layout.createSequentialGroup()
                        .addComponent(currentActionLabel, javax.swing.GroupLayout.PREFERRED_SIZE, 271, javax.swing.GroupLayout.PREFERRED_SIZE)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 48, Short.MAX_VALUE)
                        .addComponent(etaLabel)))
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(currentActionLabel)
                    .addComponent(etaLabel))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(progressBar, javax.swing.GroupLayout.PREFERRED_SIZE, 35, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>//GEN-END:initComponents

    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JLabel currentActionLabel;
    private javax.swing.JLabel etaLabel;
    private javax.swing.JProgressBar progressBar;
    // End of variables declaration//GEN-END:variables
}

 

[Kababär]

Danke mal sehenw as ich damit anfangen kann 🙂