java：对不可变Iterable的并发迭代

我有一个不可变的Iterable< X>拥有大量元素. (它恰好是一个List<>但不要紧.)

我想做的是启动一些并行/异步任务来迭代Iterable<>使用相同的迭代器,我想知道我应该使用什么接口.

这是一个带有待定接口QuasiIteratorInterface的示例实现：

public void process(Iterable<X> iterable)
{
   QuasiIteratorInterface<X> qit = ParallelIteratorWrapper.iterate(iterable);
   for (int i = 0; i < MAX_ParaLLEL_COUNT; ++i)
   {
      SomeWorkerClass worker = new SomeWorkerClass(qit);
      worker.start();
   }
}

class ParallelIteratorWrapper<T> implements QuasiIteratorInterface<T>
{
   final private Iterator<T> iterator;
   final private Object lock = new Object();
   private ParallelIteratorWrapper(Iterator<T> iterator) { 
      this.iterator = iterator;
   }
   static public <T> ParallelIteratorWrapper<T> iterate(Iterable<T> iterable)
   {
      return new ParallelIteratorWrapper(iterable.iterator());
   }
   private T getNextItem()
   {
      synchronized(lock)
      {
         if (this.iterator.hasNext())
            return this.iterator.next();
         else
            return null;
      }
   }
   /* QuasiIteratorInterface methods here */
}

这是我的问题：

>直接使用Iterator是没有意义的,因为hasNext()和next()有同步问题,如果其他人在你做之前调用next(),那么hasNext()就没用了.
>我喜欢使用Queue,但我需要的唯一方法是poll()
>我喜欢使用ConcurrentLinkedQueue来保存我的大量元素……除了我可能不得不多次迭代元素,所以我不能使用它.

有什么建议？

解决方法

使用poll()方法或等效方法(例如Guava的 Supplier)创建自己的Producer接口.实现选项很多但是如果你有一个不可变的随机访问列表,那么你可以简单地维护一个线程安全的单调计数器(例如AtomicInteger)并调用list.get(int),例如：

class Listsupplier<T> implements supplier<T> {
  private final AtomicInteger next = new AtomicInteger();
  private final List<T> elements; // ctor injected

  …
  public <T> get() {
    // real impl more complicated due to bounds checks
    // and what to do when exhausted
    return elements.get(next.getAndIncrement());
  }
}

这是线程安全的,但你可能想要返回一个Option风格的东西,或者在用尽时返回null.