分配免费游戏

我的代码基本上没有分配空间，但GC在60fps时每隔30秒运行一次。使用DDMS检查应用程序的分配情况显示，分配的ALOT为SimpleListIterator。还有一些东西被分配，因为我使用Exchanger。分配免费游戏

SimpleListIterator来自每个循环for (T obj : objs) {}。我的印象是，编译器/译者会优化那些不使用迭代器的类型支持它（我基本上只使用ArrayList），但似乎并非如此。

如何避免分配所有这些SimpleListIterators？一个解决方案是切换到定期for循环for (int i = 0; i < size; ++i) {}但我喜欢每个环:(

的另一种方法将是扩展的ArrayList它返回一个Iterator是只分配一次。

的第三种方式我入侵一起使用被重用Iterator它返回一个Collection一个静态辅助功能，我砍死像这样在一起，但铸造感觉非常hackish的和不安全的应该是线程安全的，虽然我使用ThreadLocal见下：？

public class FastIterator { 
    private static ThreadLocal<Holder> holders = new ThreadLocal<Holder>(); 

    public static <T> Iterable<T> get(ArrayList<T> list) { 
     Holder cont = holders.get(); 

     if (cont == null) { 
      cont = new Holder(); 

      cont.collection = new DummyCollection<T>(); 
      cont.it = new Iterator<T>(); 

      holders.set(cont); 
     } 

     Iterator<T> it = (Iterator<T>) cont.it; 
     DummyCollection<T> collection = (DummyCollection<T>) cont.collection; 

     it.setList(list); 
     collection.setIterator(it); 

     return collection; 
    } 

    private FastIterator() {} 

    private static class Holder { 
     public DummyCollection<?> collection; 
     public Iterator<?> it; 
    } 

    private static class DummyCollection<T> implements Iterable { 
     private Iterator<?> it; 

     @Override 
     public java.util.Iterator<T> iterator() { 
      return (java.util.Iterator<T>) it; 
     } 

     public void setIterator(Iterator<?> it) { 
      this.it = it; 
     } 
    } 

    private static class Iterator<T> implements java.util.Iterator<T> { 
     private ArrayList<T> list; 
     private int size; 
     private int i; 

     @Override 
     public boolean hasNext() { 
      return i < size; 
     } 

     @Override 
     public T next() { 
      return list.get(i++); 
     } 

     @Override 
     public void remove() { 

     } 

     public void setList(ArrayList<T> list) { 
      this.list = list; 
      size = list.size(); 
      i = 0; 
     } 

     private Iterator() {} 
    } 
}

来源

2010-12-07 alexanderblom

恩，所以如果我正确地理解你，黑客迭代器比在for循环中获取值所需的一个额外行更好... – 2010-12-07 14:18:19

已采取的措施。猜猜我应该咬在一起，并为每个循环沟？ :( – alexanderblom 2010-12-07 14:23:25

我已经使用了“扩展ArrayList，它返回一个只能分配一次的迭代器”版本，需要注意的一点是（与你提到的所有迭代类型一样）是嵌套迭代，在我的版本中我添加了一个显式的“释放“方法，并可以理智地检查迭代器是否已经被使用......以这种方式捕获了一个令人讨厌的bug另一个注意事项：让Iterator.remove抛出一个UnsupportedOperationException是合法的 – Darrell 2010-12-07 14:30:35

你不应该在Android游戏中使用它们。我认为这official video也谈到这一点。

来源

2010-12-07 14:18:31 mibollma

可能最好的方法是使用装饰设计。创建一个在构造函数中使用集合的类，并通过调用被包装的类并重新使用返回的迭代器来实现Iterable接口。

来源

2010-12-07 14:19:30 Pace

另外两种避免分配迭代器的方法。第一种是使用一个回调成语：

public interface Handler<T> { 
    void handle(T element); 
} 

public interface Handleable<T> { 
    void handleAll(Handler<T> handler); 
} 

public class HandleableList<T> extends ArrayList<T> implements Handleable<T> { 
    public void handleAll(Handler<T> handler) { 
    for (int i = 0; i < size(); ++i) { 
     handler.handle(get(i)); 
    } 
    } 
}

这种方法仍然需要处理程序的实例接收回调，但这绝对可以减少分配时，例如，您尝试访问的几个要素名单。

第二种方法是使用游标成语：

public interface Cursor<T> { 
    void reset(); 
    boolean next(); 
    T current(); 
} 

public class CursoredList<T> extends ArrayList<T> implements Cursor<T> { 
    private int _index = -1; 

    public void reset() { 
    _index = -1; 
    } 

    public boolean next() { 
    return ++_index >= size(); 
    } 

    public T current() { 
    return get(_index); 
    } 
}

当然，这是一样的对你的ArrayList亚型实施可迭代和迭代器，但是这清楚地表明集合本身的光标位置作为状态。

来源

2010-12-07 19:54:32

分配免费游戏

回答

相关问题