# Java-Programm richtig neustarten?



## Verjigorm (5. Sep 2008)

Und zwar habe ich folgendes Problem:

Als Idee zum Neustarten einer Applikation gibts nen Neustart-Button, welcher auf dem aktuellen Fenster ein dispose aufruft und dann die main(...) aufruft.

Klappt soweit auch. Nur ist mir dann im profiler aufgefallen, dass die zuvor geladenen Daten (~20mb) weiterhin im Speicher verharren. Wenn ich also "neustarte" und wieder die Daten lade, sinds dann 40mb Heapspace, nochmal neustarten und laden 60mb usw.

Ist zwar an sich nicht wirklich schlimm, da ich mal nicht davon ausgehe, dass das jemand 20mal hintereinander macht, aber mich interessiert nun doch die Frage:

Wie startet man eine Applikation denn aus sich heraus am saubersten neu und gibt nichtmehr benötigte Ressourcen frei??
Ein System.gc() an verschiedensten Stellen hat leider kein Erfolg gezeigt.

(Bitte fragt jetzt nicht nach einem lauffähigem Testprogramm :autsch

mfg Verjigorm


----------



## SlaterB (5. Sep 2008)

wenn du schon keins posten willst, dann mach ich mir den Spaß 


```
public class TestGUI
    extends JFrame
{
    static int count = 0;
    private int[] a = new int[5000000];

    public TestGUI()
        throws Exception
    {
        super("Nummer: " + count++);
        setSize(100, 100);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

    public static void main(String[] args)
        throws Exception
    {
        Runtime r = Runtime.getRuntime();
        for (int i = 10; i < 40; i++)
        {
            TestGUI g = new TestGUI();
            Thread.sleep(500);
            System.out.println(i+" mit : "+(r.totalMemory()-r.freeMemory()));
            g.dispose();
            g = null;
            System.gc();
            Thread.sleep(500);
            System.out.println(i+" ohne: "+(r.totalMemory()-r.freeMemory()));
        }
    }
}
```
ein Fenster braucht um die 20 MB,
mit System.gc ist die Ausgabe beispielsweise

```
10 mit : 20504528
10 ohne: 20560888
11 mit : 20557896
11 ohne: 20520304
12 mit : 40547472
12 ohne: 20496304
13 mit : 40607456
13 ohne: 20570112
14 mit : 40607664
14 ohne: 40508744
15 mit : 60635736
15 ohne: 20506544
16 mit : 40633536
16 ohne: 20506520
17 mit : 40633512
17 ohne: 20507328
18 mit : 40634320
18 ohne: 20507280
19 mit : 40634272
19 ohne: 20507280
```
ohne gc() bei mir beispielsweise

```
10 mit : 20504528
10 ohne: 20515040
11 mit : 40622512
11 ohne: 40622512
12 mit : 60668208
12 ohne: 60668208
13 mit : 60638480
13 ohne: 60638480
14 mit : 60641160
14 ohne: 60641160
15 mit : 60644456
15 ohne: 60644456
16 mit : 60647136
16 ohne: 60647136
17 mit : 60640048
17 ohne: 60640048
18 mit : 60642728
18 ohne: 60642728
19 mit : 60642728
19 ohne: 60642728
20 mit : 60645408
20 ohne: 60645408
21 mit : 60640048
21 ohne: 60640048
22 mit : 60640048
22 ohne: 60640048
23 mit : 60640048
23 ohne: 60640048
24 mit : 60640048
24 ohne: 60640048
25 mit : 60640832
25 ohne: 60640832
26 mit : 60640832
26 ohne: 60640832
27 mit : 60640832
27 ohne: 60640832
28 mit : 60643512
```
da wird also weniger aufgeräumt, trotzdem kommt es nicht (unbedingt) zur Exception,

vergrößere ich allerdings das Array z.B. auf 7000000,
so bekomme ich auch mit gc ne Exception:

```
10 mit : 28504528
10 ohne: 28657856
11 mit : 56629368
11 ohne: 28590008
12 mit : 56632912
12 ohne: 56509936
13 mit : 28631856
13 ohne: 28590160
14 mit : 56633064
14 ohne: 56508512
15 mit : 28632664
15 ohne: 28506672
16 mit : 56633664
16 ohne: 56510432
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
```
es sollte also mindestens Speicher für drei Kopien da sein, vielleicht auch 10,

das ist jetzt keine wissenschaftliche Aussage ,
aber zumindest erhöht sich der Bedarf nicht beliebig, es wird auch freigeräumt


> Wenn ich also "neustarte" und wieder die Daten lade, sinds dann 40mb Heapspace, nochmal neustarten und laden 60mb 

wenn du nur den angeforderten Speicher des Programms meinst, dann kann das ja gut sein,
neuen freien Speicher zu belegen ist immer leichter als alten aufzuräumen,
begrenze den Speicher des Programmes, 
so viel wie ihm zusteht, wird es doch wohl auch voll nutzen dürfen


----------



## Ladi (5. Sep 2008)

Hallo Verjigorm,

erstens, es fällt mir für die Idee eine laufende Anwendung aus ihr selbst neuzustarten kein Grund ein. Es schaut mir nach einem Workaround für ein richtiges Problem, welches man nicht finden kann. Hast du ein Problem mit einem Mamory Leak, dann schau nach einem Profiler.

Folgede Info für dich:

Du beendest ja nicht die virtuelle Machine, d.h. alles was die sich geladen hat bleibt im Speicher. Hierzu gehört folgendes:
- Klassen
- Alle statischen Daten - verwendest Du z.B. statische Caches, bleiben diese im Speicher geladen solange JVM läuft.

Diese werden (wenn nicht entsprechend programmiert) auch nicht vom Garbage Collector beseitigt.

Vielleicht wäre es sinnvoll, wenn Du hier schreibst, warum du diese Aktion überhaupt machen willst.

Gruß
Ladi


----------



## Ark (5. Sep 2008)

Ein Aufruf von main() ist nur ein weiterer Aufruf von main() und daher einem Neustart nicht einmal im Ansatz ähnlich. Initialisierungen in static-Blöcken werden beispielsweise nicht mehr vorgenommen. Und selbst, wenn dein Programm beim "Neustart" keine weiteren Ressourcen benötigen würde: der Call-Stack wächst trotzdem an. Gekürzt sieht deine Situation also wie folgt aus:

```
public static void main(String[] args){
    main(args);
}
```
Ich erinnere mich, dass man irgendwie/irgendwo festlegen konnte, was als allerletzter Befehl (quasi direkt nach Beenden von java) ausgeführt werden soll. Dort müsstest du dann den Start deiner Anwendung als Befehl angeben. Wie aber schon gesagt wurde, sollte man versuchen, solche Probleme grundsätzlich zu vermeiden.

Ark


----------



## Verjigorm (5. Sep 2008)

Jo, das Memory Leak ist ja das Problem:

Die Applikation lädt Firmendaten (~20mb).
Lädt man nun 5-6 Firmen nacheinander ein, braucht das Ding gut 200MB Heapspace.
Das war bisher kein Problem, aber nun wurde ein Webservice hinzugefügt, der diese geladenen Daten (nur jeweils dieses eine letzte 20mb-file) in ein byte-Array umwandelt und verschickt.

Was an sich auch funktioniert, SOLANGE man VORHER nicht zuviel HeapSpace angestaut hat. Lädt man erst 6-7mal irgendwelche Daten ein (was bei normalem Arbeitsbetrieb ständig ist) dann kommt irgendwann HeapSpace-Exception

Da ich das Grundprogramm nicht kenne, sondern nur den Webservice eingefügt habe, habe ich extrem wenig Plan von dem Laden/Speichern und so.
Dachte ich könnte das Problem einfach übergehen, indem die Applikation vorm Laden neugestartet wird, war aber nicht der Fall.

Edit: meinen verbrauchte Heapspace beim konvertieren und verschicken der Daten kann ich nach dem Senden auf ein Minimum wieder reduzieren.
Setze alle Referenzen auf null und ruf den GC auf.
Auf den Speicherverbrauch vorher hab ich halt wenig Kontrolle.


----------



## Ladi (5. Sep 2008)

Hallo Verjigorm,

falls Du die fehlerhafte Anwendung im Griff hast, würde ich mir auf jeden Fall überlegen die zu profilieren. Memory leaks sind in Java mit den richtigen Tools sehr schnell und einfach zu finden. Meistens handelt es sich um zyklische Referenzen, oder falsch programmierte Caches.

Falls Du ihn nicht im Griff hast und auf dem Neustarten bestehst, würde ich es wahrscheinlich vom aussen mit Betriebssystemmitteln stricken.

Oder probiere den Tipp vom Ark zu verfolgen.

Gruß
Ladi


----------



## Ark (5. Sep 2008)

Mit 
	
	
	
	





```
java.lang.Runtime.addShutdownHook(Thread hook)
```
 kannst du sowohl bei "normalem" Beenden als auch bei Abstürzen (Errors/Exceptions) garantieren, dass ein Befehl ausgeführt wird. Dazu musst du nur für hook einen Code programmieren, der beispielsweise mit 
	
	
	
	





```
exec(String[] cmdarray)
```
 dein Programm wieder startet. Probiert habe ich das allerdings noch nicht, die Dokumentation dazu habe ich auch nur überflogen.

Ark


----------



## Campino (7. Sep 2008)

Ark: Ich hab mal in einem Programm, das auf eine Datenbank zugriff die DB- Connection in so einem Hook geschlossen um ganz sicher sein zu können, das ich das auch nicht vergesse, dass klappte eigentlich ganz gut.


----------



## FArt (7. Sep 2008)

Ark hat es schon gesagt: der "Neustart" über main() ist Käse. Vom GC wird alles abgeräumt, was nicht mehr referenziert wird. Vermutlich hast du irgendwelche static-Felder, die die alten Daten noch refernzieren.
Kümmer dich um das Problem, und du kannst ohne "Neustart" beliebig oft neue Firmendaten einlesen.


----------



## dev/null (8. Sep 2008)

Was Du auch machen könntest wäre z.B. eine 2te Jar, die nur den Zweck hat Dein Hauptprogramm neu
zu starten.

Dann könntest Du so was machen wie


```
Runtime.getRuntime().exec("java -jar " + Pfad);
System.exit(1);
```

Und in deinem Jar fürs neu starten dann halt das gleiche nur mit dem Pfad zu deiner eigentlichen Anwendung.
Damit wird die VM beendet, also wenn vorher noch etwas gespeichert oder geschlossen werden soll, dann besser
vorher machen.

Nur so auf die schnelle ne Idee, gibt bestimmt elegantere Lösungen, aber sollte klappen.

mfg


----------

