Instanzen herunterzählen

Status
Nicht offen für weitere Antworten.

weijg

Mitglied
ich habe hier einen Konstruktor:

Code:
             public Medium(int mediennummer,Strin titel){

                     anzInstanzen++; //als static  variable definiert wurde
                     this.mediennummer = mediennummer;
                     this.titel = titel;

}
wenn ein Instanze erzeugt wurde, wurde anzInstanzen hochgezählt.

aber falls Objekte gelöscht werden sollten, in welcher Methode muss die Anzahl der Instanzen heruntergezählt werden.

Code Tags eingefügt /Stefan1200
 
tja also wenn ich das richtig verstanden habe soll, willst du in der gleichen klasse eine static variable hochzählen wenn eine neue instanz dieser erstellt wird und in der gleichen klasse runterzählen wenn diese instanzen zerstört wird.......

na hola die waldfee, wenn du das hinbekommt, kriegste den nobelpreis....

man kann doch nich in der gleichen klasse ne variable laufen lassen die zählt wenn du ne instanz dieser klasse erzeugtst oder zerstörst ...mach doch das in der klasse in der du diese instanzen heraus erzeugst und zerstörst und nich in der gleichen klasse die erzeugt/zerstört wird...

oder hab ich da was falsch verstanden???dann sorry, aber genauere angaben, plz...!!!

grützl
 
Code:
class KlasseDieGezaehltWird{
//Instanzvariablen
private static int anzInstanzen=0;

public KlasseiDieGezaehltWird(){
    anzInstanzen++;
}
public static void remInstanz(){
    anzInstanzen--;
}
}

Aufruf funktioniert so;

Code:
KlasseDieGezaehltWird k = new KlasseDieGezaehltWird();

k=0;
KlasseDieGezaehltWird.remInstanz();
 
manche Instanzen werden nie zerstört (wenn du genug speicher hast)

aber wenns denn sein muss: finalize
 
Ansonsten kannste auch Referenzen auf deine Instanz in einem Set / einer Map hinterlegen. Bei Bedarf einfach die Map entsprechend pflegen. Die Anzahl der Referenzen im Container entspricht somit der Anzahl deiner Instanzen...
 
Hierzu noch etwas aus em Handbuch der Java Programmierung:

Tatsächlich garantiert die Sprachspezifikation nicht, daß ein Destruktor überhaupt aufgerufen wird. Wenn er aber aufgerufen wird, so erfolgt dies nicht, wenn die Lebensdauer des Objektes endet, sondern dann, wenn der Garbage Collector den für das Objekt reservierten Speicherplatz zurückgibt. Dies kann unter Umständen nicht nur viel später der Fall sein (der Garbage Collector läuft ja als asynchroner Hintergrundprozeß), sondern auch gar nicht. Wird nämlich das Programm beendet, bevor der Garbage Collector das nächste Mal aufgerufen wird, werden auch keine Destruktoren aufgerufen. Selbst wenn Destruktoren aufgerufen werden, ist die Reihenfolge oder der Zeitpunkt ihres Aufrufs undefiniert. Der Einsatz von Destruktoren in Java sollte also mit der nötigen Vorsicht erfolgen.

Nur als Ergänzung zu dem was Bleiglanz gepostet hat.
 
Hallo,

es gibt da einen Weg, den Garbage-Collector zu belauschen, allerdings solltest Du das nur tun, wenn es nicht zu viele beobachtete Instanzen sind, weil damit ein gewisser Overhead einhergeht.

sky80 hat die Lösung ohne es zu ahnen schon skizziert:
Stecke Deine Referenzen als key in eine WeakHashMap. Das Objekt, dass du als value nimmst, ist in
diesem Fall völlig egal, es sollte immer dasselbe sein, um Ressourcen zu sparen.

Der Witz ist folgender:
An entry in a WeakHashMap will automatically be removed when its key is no longer in ordinary use. More precisely, the presence of a mapping for a given key will not prevent the key from being discarded by the garbage collector, that is, made finalizable, finalized, and then reclaimed. (API)

Wenn also ein Objekt weggeräumt wird, sinkt die Anzahl Mappings - die gesuchte Zahl der noch existierenden Instanzen.

Ich habe leider momentan keine Möglichkeit, Dir ein Codebeispiel zu geben, aber vielleicht fühlt sich ja
virgie82 angespornt, sich selbst den Nobelpreis zu holen, den sie oder er (?) ausgelobt hat 😀) ?

Gruß,

Karl
 
Hallo,

für die, die es interessiert, hier die Beispielimplementierung, um dem Garbage-Collector bei der Arbeit zuzusehen:
Code:
package prob;

import java.util.WeakHashMap;

/**
 * Beispiel, um die Arbeit des Garbage Collectors (GC) zu beobachten.
 * 
 * @author Karl Eilebrecht, 2005-01-29
 */
public class GCDemo {

	/**
	 * Hier werden die Instancen als Schlüssel verwaltet.
	 */
	private static final WeakHashMap INSTANCES = new WeakHashMap();

	/**
	 * Die WeakHashMap dient nur zum Zählen, daher ein DUMMY-Wert, als key wird
	 * die jeweilige Instanz benutzt.
	 */
	private static final Integer DUMMY_VALUE = new Integer(0);

	/**
	 * Eine Instanz soll auch etwas mehr Speicher verbrauchen, sonst dauert es
	 * ewig, bis der GC anspringt.
	 */
	private static final int INSTANCE_MEMORY_CONSUMPTION = 100;

	/**
	 * Zusätzlicher Speicher, den die Instanz zusätzlich verschwendet.
	 */
	private byte[] memory = new byte[INSTANCE_MEMORY_CONSUMPTION];

	/**
	 * Constructor Jede Instanz kommt direkt in die Verwaltung
	 */
	public GCDemo() {
		INSTANCES.put(this, DUMMY_VALUE);
	}

	/**
	 * Gibt die Anzahl der Instanzen zurück, die der GC noch nicht im Auge hat.
	 * 
	 * @return Zahl der Instanzen
	 */
	public static int getInstanceCount() {
		return INSTANCES.size();
	}

	/**
	 * Testmethode Es werden immer 100 Instanzen erzeugt, und dann wird die
	 * Anzahl lebender ausgegeben. TODO: Parametrisierung
	 * 
	 * @param args,
	 *            noch ohne Bedeutung
	 */
	public static void main(String[] args) {
		StringBuffer buf = new StringBuffer(25);
		int lastCount = 0;
		System.out.println("Zeitindex(ms) , Anzahl , Abgeräumt(GC)");
		long startTime = System.currentTimeMillis();
		for (int i = 0; i < 50000; i++) {
			GCDemo instance = new GCDemo();
			if (i % 100 == 0) {
				int count = GCDemo.getInstanceCount();
				buf.append(System.currentTimeMillis() - startTime);
				buf.append(" , ");
				buf.append(count);
				if (count < lastCount) {
					buf.append(" , ");
					buf.append(lastCount - count);
				}
				System.out.println(buf);
				buf.delete(0, 25); //Ausgabespeicher löschen
				lastCount = count;
			}
		}
	}
}

Wenn man die gewonnenen CSV-Daten nach Excel importiert, kann man schön sehen, wann der GC aktiv wird.
Richtig unter Dampf setzt man das Freundchen, wenn man INSTANCE_MEMORY_CONSUMPTION hoch dreht.


Gruß,

Karl
 
Status
Nicht offen für weitere Antworten.

Neue Themen


Zurück
Oben