Contador de Instancias

não sei exatamente se é possivel fazer isso…

mas vc poderia criar um contador static no construtor do objeto, para saber qtos tem atualmente…
++ e – de acordo com a criação e destruição deles…

Não desse modo! O Java não consegue trabalhar nesse nível de memória ( creio que você deva ter vindo do C/C++, então lamento te informar, mas... rsrs, izo no ecxiste).

O que você pode fazer é como alucardeck falou, cria um atributo estático e faça a contagem por ele... o lado ruim é que você nunca vai conseguir diminuir esse número, a não ser que você coloque como padrão que todo código deverá informar quando finalizar o processamento com um objeto. Exemplo:

public void metodoQualquer() {
    DAO dao  = new DAO();

    dao.blablabla();

    dao.finalizeInstance();
}

E na classe DAO, assim como todas as outras, você poderia fazer algo como:

public class ManagerInstances {

   private int count;

   protected int getCount() {
        return this.count;
   }


   public void add() {
        this.count += 1;
   }

   public void remove() {
        this.count -= 1;
   }

}

E sua classe DAO, bem como todas as outras que você queira gerenciar, ficaria:

public class DAO {
    private static ManagerInstances managerInstances;


    public DAO() {
         if (managerInstances  == null) 
               managerInstances  = new ManagerInstances();

         managerInstances.add();
    }


    public void finalizeInstance() {
          managerInstances.remove();
    }
}

E se quiser fazer algo realmente ninja, faça seu "GarbageCollector" rsrsrs, que na verdade será: Crie um método publico para resgatar a quantidade de instancias!

E com Reflection, percorra todas as classes, veja se ela tem um gerenciamento de instancias, e pegue a quantidade, e ai faça uma contabilização, gere relatório, o que você quizer.

Só que é aquele negócio... se alguem esqueçer de chamar o finalizeInstance... "melo" a brincadeira.

Falows

Melhor do que isso, só dois disso!
Valeu pela explicação, cara!
Abraço!

Uma vez que vc sabe quantas instâncias vc tem, o que vc fará?

Um pool de conexões?

Ainda não pensei nisso…
A principio, era somente uma curiosidade sobre a linguagem mesmo…
Abraço!

public class Cerveja {

	public static int count = 0;
	
	public Cerveja() {
		++count;
	}
	
	@Override
	protected void finalize() throws Throwable {
		--count;
	}
}

public class Main2 {

	public static void main(String[] argv) {
		Cerveja a = new Cerveja();
		System.out.println(a.count);

		Cerveja b = new Cerveja();
		
		System.out.println(a.count);
		
		b = null;
		
		System.gc();
		
		System.out.println(a.count);
	}
}

deve produzir a saída:

1
2
1

Se a instanciação dos objetos é gerenciada, então é muito fácil obter esse tipo de informação caso contrário não.

Se a instanciação for feita via um objeto que gerencie essa criação é muito fácil fazer a contagem de instâncias. Se novas instâncias forem criadas em qualquer lugar do código e de qualquer forma, o negócio fica mais difícil.

Olha esse exemplo da Apache Pool.

http://commons.apache.org/pool/examples.html

Dá uma olhada também no javadoc do ObjectPool. Lá, por exemplo existe um método de contar instâncias ativas no pool.

http://commons.apache.org/pool/api-1.4/org/apache/commons/pool/ObjectPool.html

Não é tão diretamente ligada a sua pergunta, mas é possível ter uma idéia de como gerenciar seus objetos.

se vc ker algo facil e rapido
tambem seria possivel criar um arrayList static do tipo q vc ker…

entao vc usa add e remove…
e no final vc pega o size do arrayList para saber o tamanho…

mas lembrando q todos os objetos instanciados devem ser adicionados nesse arrayList “global”…

de qqer forma o pool parece ser a melhor solução…

Tava pensando aqui…
E se o Garbage Colector detonar os objetos que criei na memoria por não estarem mais em uso?

Eu perco totalmente o controle da contagem, certo?

vinny767:

Tava pensando aqui…
E se o Garbage Colector detonar os objetos que criei na memoria por não estarem mais em uso?

Eu perco totalmente o controle da contagem, certo?

Se o método finalize for chamado e vc diminui a contagem no finalize…

Se bem q vc poderia transmitir esse controle para o Hibernate

vinny767:

Tava pensando aqui…
E se o Garbage Colector detonar os objetos que criei na memoria por não estarem mais em uso?

Eu perco totalmente o controle da contagem, certo?

Digamos, se seus objetos estiverem num pool, e existir uma referência a este pool esses objetos não vão ser removidos pelo GC.

Um exemplo não compilável

Pool p = PoolFactory.createPoo();

p.addToPool(new Object());
p.addToPool(new Object());
p.addToPool(new Object());

No exemplo acima, enquanto existir “p” os objetos contidos nele não serão removidos.

peczenyj:

vinny767:

Tava pensando aqui…
E se o Garbage Colector detonar os objetos que criei na memoria por não estarem mais em uso?

Eu perco totalmente o controle da contagem, certo?

Se o método finalize for chamado e vc diminui a contagem no finalize…

Se bem q vc poderia transmitir esse controle para o Hibernate ;-)

Eu acho que ele está apenas entender o mecanismo, e não implementar algo para a “vida real”. Não sei.

Exato…

Por isso eu sugeri o finalize

Por isso eu sugeri o finalize ;-)

E eu me referi a parte que você escreveu sobre o Hibernate. Não prestei a devida atenção no que escreveste no início.

My bad.