Será que isso causar problemas de coleta de lixo

Question

Eu escrevi um pouco Linq como DSL no topo Google Collections

    public class IterableQuery {

   public static <T> Where<T> from(Iterable<T> originalCollection) {
      return  new Where<T>( Iterables.transform(originalCollection, IterableQuery.<T>SAME()));
   }

   private static <T> Function<T, T> SAME() {
      return new Function<T, T>(){
         public T apply(T arg0) {
            return arg0;
         }
      };
   }


   public static class SelectOrderBy<T>{

      private final Iterable<T> iterable;

      public SelectOrderBy(Iterable<T> iteable) {
         this.iterable = iteable;
      }

      public  SelectOrderBy<T> orderyBy( Comparator<T> sort ){
          Ordering.forComparator(sort).sort((List< ? extends T>) iterable);
          return new SelectOrderBy<T>( iterable);
      }

      public  <F> Iterable<F> select(  Function<? super T,? extends F> function){
         return Iterables.transform(iterable, function);
      }
      public  Iterable<T> selectEveryThing( ){
         return iterable;
      }
   }


   public static class Where<T>{

      private final Iterable<T> iterable;

      public Where(Iterable<T> iterable) {
         this.iterable = iterable;
      }

      public    SelectOrderBy<T> where(Predicate<T> predicate) {
         return  new SelectOrderBy<T>( Iterables.filter(iterable, predicate));
      }
   }

}

para que eu pudesse fazer consulta coleções de forma legível mais conciso

 Iterable<? extends NewOrder > currentlyAssigned = 
         IterableQuery.
          from(orders).
          where(placedInLast10Days).
          orderBy(lastName). 
          select(orderToNewOrder);

Estou preocupado se esta abordagem irá causar uma explosão de mini objetos e causar alguns problemas de coleta de lixo (ou quaisquer outras questões)?

Answer 1

Eu acredito que usa o Google Coleções execução adiada para a maioria de seus Iterators. execução diferida iria minimizar o número de objetos intermediários criados como seria eliminar a maioria dos intermediários listas / temporários que podem ser criados para cada chamada (onde, orderby, etc).

Basicamente, a cada elemento retornado por currentlyAssigned.iterator () não é calculado até que você chamar iterator.next (). Até então, o seu currentlyAssigned iterable é apenas um conjunto de operações, nada mais.

Sua única preocupação sobre a explosão de mini-objetos se os objetos durar mais tempo do que a duração de um uso único elemento de memória operação ... pico poderia se tornar bastante grande nesse caso e você pode potencialmente ficar sem memória em grande listas ou se foram convertendo objetos (ie chamando ToUpper () em todas as cordas ou algo assim). Isso só seria o caso se o resultado de onde () era uma outra lista, em seguida, orderby () criou uma outra lista, assim por diante e assim por diante.

Quanto ao GC manipulação muitos fugaz objetos, não há nenhum problema. O coletor de lixo moderno Java altamente otimizado para lidar com esse comportamento exato.

Answer 2

Eu acho que isso depende de como transformar se comporta, se é como um filtro preguiçoso, ou seja, você não anexar uma referência para cada resultado. em seguida, a sua mais do que a contagem objeto OK sábio. A coleta de lixo sábio, você não está mantendo todas as referências ocultas, uma vez que você perde a referência de raiz todo o gráfico torna-se inacessível e é coletado. caminho a percorrer homem este é realmente puro.

Answer 3

O coletor de lixo tem código especial para objetos de vida curta, e eles são muito, muito barato de usar. Basicamente vez em quando todos os jovens objetos acessíveis são marcadas e todas as outras objeto é recuperado em um só golpe.