Hallo,

okay, habs mit dem unter Ubuntu 64 Bit mit dem Open JDK 1.6.0_0 laufen lassen.

Damit das Problem auf jeden Fall auftritt reduzieren wir die Heap Size mal auf 48 MB. -Xmx48m

@limago:

Achtung Spoiler:

Die Liste zu entfernen und nachträglich wieder hinzuzufügen ist keine zuverlässige Lösung... -> mit kleineren Heap Konfiguration gibt es trotzdem OOMEs. Ich bekomme auch mit 256 MB OOME's bei deiner Lösung.

@All

Achtung Spoiler:

die Ursache für den OOME liegt in der Implementierung der Liste...
Vielleicht machen ja manche Methoden nicht ganz das was man von ihnen erwartet...

Gruß Tom

Das hier ist sicher nicht in Toms Sinn erfüllt aber alle Foderungen * grins *

Achtung Spoiler:

package de.tutorials;


import java.util.List;

public class MemoryLeakExample {
public static void main(String[] args) {
List<List<?>> lists = new ArrayList<List<?>>();

for(int i = 0; i < 100;i++){
List<Integer> list = new ArrayList<Integer>();

for(int j = 0; j < 1000000;j++){
list.add(j);
}
lists.add(list);

System.out.println(i);
list.clear();
//?


}

System.out.println(lists);
}

static class ArrayList<T> extends java.util.ArrayList<T> {
public boolean add( T element) {
if (element instanceof List)
super.add(element);
return true;}
}
}

Hallo,

Das hier ist sicher nicht in Toms Sinn erfüllt aber alle Foderungen * grins *

Ist auch nicht wirklich gültig, da der Code nicht an der Stelle des ? eingefügt wurde... -> Regeln erweitert / klarer gemacht

Gruß Tom

Hmm...

Achtung Spoiler:
i = 100;

Ich denke richtig ist:

Achtung Spoiler:
((ArrayList<Integer>)list).trimToSize( );
clear() setzt nur die Elemente im Array der ArrayList auf null und die Größe auf 0, aber behält die Größe des Arrays bei. Daher bleibt der Speicher auch reserviert.

Hat zwar nen bisschen gedauert bis ich drauf gekommen, aber wohl eher weil ich das Problem überschätzt habe. Hier meine Lösung:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

[COLOR="whitesmoke"] import java.util.ArrayList; import java.util.List;   public class MemoryLeakExample {     public static void main(String[] args) {         List<List<?>> lists = new ArrayList<List<?>>();                 for(int i = 0; i < 100;i++){             List<Integer> list = new ArrayList<Integer>();                         for(int j = 0; j < 1000000;j++){                 list.add(j);             }             lists.add(list);                         System.out.println(i);             list.clear();             i = 100;         }                 System.out.println(lists);     } } [/COLOR]

Hallo,

die Schleifenvariablen zu manipulieren ist nicht wirklich eine Lösung... oder würdet ihr etwa so ein Speicherproblem in production code lösen? Durch verändern der Business Logic? In den meisten Fällen wird das wohl keine so gute Idee sein...

Gruß Tom

Achtung Spoiler:

Habe die Liste die geleert wurde wieder auch von der array size gestaucht. Bei mir gehts mit 48MB heap(und weniger) auf Windows 7 & sun jre 6-17 auf x86_64 bit Maschine

package de.tutorials;

import java.util.ArrayList;
import java.util.List;

public class MemoryLeakExample {
public static void main(String[] args) {
List<List<?>> lists = new ArrayList<List<?>>();

for(int i = 0; i < 100;i++){
List<Integer> list = new ArrayList<Integer>();

for(int j = 0; j < 1000000;j++){
list.add(j);
}
lists.add(list);

System.out.println(i);
list.clear();
//+
ArrayList<?> ar = (ArrayList<?>) list;
ar.trimToSize();
//-
}

System.out.println(lists);
}
}

Hallo,

ein Aufruf von trimToSize() war natürlich des Rätsels Lösung.

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

package de.tutorials;   import java.util.ArrayList; import java.util.List;   public class MemoryLeakExample {     public static void main(String[] args) {         List<List<?>> lists = new ArrayList<List<?>>();         for(int i = 0; i < 100;i++){             List<Integer> list = new ArrayList<Integer>();                         for(int j = 0; j < 1000000;j++){                 list.add(j);             }             lists.add(list);                         System.out.println(i);             list.clear();             ((ArrayList<?>)list).trimToSize();         }         System.out.println(lists);     } }

Das Beispiel sollte nochmal vor Augen führen, dass auch in Code der auf den ersten Blick sauber ausschaut üble Memory Leaks verborgen sein können die man nur durch genaue Kenntnisse der Implementierungsdetails der Java API auflösen kann.

Andere Collection Klassen wie HashMap, LinkedHashMap, ConcurrentHashMap etc. haben dieses Problem auch, bieten jedch keine Möglichkeit nachträglich die internen Strukturen (hier Hash-Buckets / Segments) zu stutzen.

TreeMap hat dieses Problem IMHO nicht. Dort wird beim clear() die Referenz auf den zugrundeliegenden RB-Tree (RedBlack) null gesetzt, so dass die internen Strukturen, soweit nicht mehr sonstwie referenziert, vom GC aufgesammelt werden können.

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

package de.tutorials;   import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.TreeMap; import java.util.concurrent.ConcurrentHashMap;   public class MemoryLeakExample {     public static void main(String[] args) {         List<Map<?,?>> maps = new ArrayList<Map<?,?>>();         for(int i = 0; i < 100;i++){             Map<Integer, Integer> map =                 new TreeMap<Integer, Integer>(); //Läuft durch                 //new HashMap<Integer, Integer>(); //OOME                 //new LinkedHashMap<Integer, Integer>(); //OOME                 //new ConcurrentHashMap<Integer, Integer>(); //OOME                         for(int j = 0; j < 100000;j++){                 map.put(j,j);             }             maps.add(map);                         System.out.println(i);             map.clear();             System.out.println(map);         }         System.out.println(maps);     } }

Gruß Tom

Hallo,

zum Jahres auftakt gibts dann mal ein neues (einfaches) Rätsel:

Gegeben:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

package de.tutorials;   import java.util.LinkedHashMap; import java.util.Map;   public class LRUMapExample {     public static void main(String[] args) {         int maxEntriesToKeep = 10;                 Map<Integer, Integer> lruMap = new LinkedHashMap<Integer, Integer>();           for (int i = 0; i < 1000; i++) {             lruMap.put(i, i);         }           System.out.println(lruMap);     } }

Wie macht man hier am einfachsten aus einer LinkedHashMap eine LRU Map (Last Recently Used) welche sich nur die letzten 10 hinzugefügten Elemente merkt?

Um dann folgende Ausgabe zu erzeugen:

Code :

1	{990=990, 991=991, 992=992, 993=993, 994=994, 995=995, 996=996, 997=997, 998=998, 999=999}

?

Viel Spaß und ein frohes neues Jahr allerseits

Gruß Tom

Nice...

Achtung Spoiler:

import java.util.LinkedHashMap;
import java.util.Map;

public class LRUMapExample {

public static void main(String[] args) {
final int maxEntriesToKeep = 10;

Map<Integer, Integer> lruMap = new LinkedHashMap<Integer, Integer>( ) {
@Override
protected boolean removeEldestEntry(
java.util.Map.Entry<Integer, Integer> eldest) {
return this.size( ) > maxEntriesToKeep;
}
};

for (int i = 0; i < 1000; i++) {
lruMap.put(i, i);
}

System.out.println(lruMap);
}

}

Hallo,

bin mir nicht ganz sicher ob ich deine Aufgabenstellung richtig verstehe *schäm*, aber wie wärs mit:

Code :

1 2 3

for (int i = 1000-maxEntriesToKeep; i < 1000; i++) {             lruMap.put(i, i);         }

?

Gruß
DEV

Dann kannst du gleich folgendes verwenden:

Code :

1 2 3

for (int i = 990; i < 1000; i++) {     lruMap.put(i, i); }

PS: Die Frage ist schon knapp ein Jahr alt..

PS: Die Frage ist schon knapp ein Jahr alt..

Oh mann, das passiert mir heute schon das zweite mal

Das passiert, weil unter den Threads immer so komische Vorschläge mit ähnlichen Threads kommen; leider sind die wohl größtenteils alt ....

Gruß
DEV

Auch wenn es jetzt schon ein Jahr her ist: was spricht gegen ein neues Rätsel?

Thema: Annotations

Gegeben ist die folgende Klasse:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

package de.tutorials;   import java.util.Date;   public class AnnotationExample {     private static String supUnused1 = "unused";     private static String supDeprecation1 = "deprecation";     private static final String supUnused2 = "unused";     private static final String supDeprecation2 = "deprecation";     private static final String[] suppressArray = { "unused", "deprecation" };       public static void main(String[] args) {         // Test 1         @SuppressWarnings( { "unused", "deprecation" })         new Date().getDay();           // Test 2         @SuppressWarnings( { "unused", "deprecation" })         int a = new Date().getDay();           // Test 3         @SuppressWarnings( { supUnused1, supDeprecation1 })         int b = new Date().getDay();           // Test 4         @SuppressWarnings( { supUnused2, supDeprecation2 })         int c = new Date().getDay();           // Test 5         @SuppressWarnings(suppressArray)         int d = new Date().getDay();     } }

Die Fragen sind:
- wie reagiert der Compiler mit Java 1.6?
- welche Tests funktionieren, welche nicht und warum nicht?
Der Code sollte wenns geht nicht vorher ausgeführt werden

Viel Spaß beim Knobeln (oder Wissen )!

Viele Grüße,
MAN

Hallo,

wie sollen wir denn die Lösung angeben...?
Hier kommen mehere Dinge zusammen die man aber IMHO etzten endes aber alle unter der Kategorie Syntaxfehler abtun kann, wobei einige Fehler offensichtlich sind und andere eher subtil daher kommen

Gruß Tom