并发填充列表中的经典for loop vs Arraylist forEach-Java 8

Question

我正在对数组列表使用Java8迭代器。假设我有一个futures的ArrayList，在使用经典的for循环和使用ArrayList foreach之间有什么问题/建议吗？（除了不能从lambda表达式中抛出异常之外）

假设未来主义者同时被填补，最好的方法是什么？最后一个foreach示例是否容易出现问题？

@Override
public void forEach(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    final int expectedModCount = modCount;
    @SuppressWarnings("unchecked")
    final E[] elementData = (E[]) this.elementData;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        action.accept(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

public void waitForCompletion(List<Future<HttpResponse>> futureList) {
    futureList.forEach(future -> {
        try {
            future.get();
        } catch (InterruptedException | ExecutionException e) {
            LOG.error("Something went wrong: ", e);
        }
    });
}

private void waitForCompletion(List<Future<HttpResponse>> futureList) {
    for(int i=0; i < futureList.size(); i++) {
        try {
            futureList.get(i).get();
        } catch (InterruptedException | ExecutionException e) {
            LOG.error("Something went wrong: ", e);
        }
    }
}

private void waitForCompletion(List<Future<HttpResponse>> futureList) {
    for(Future<HttpReponse> future:futureList) {
        try {
            future.get();
        } catch (InterruptedException | ExecutionException e) {
            LOG.error("Something went wrong: ", e);
        }
    }
}

Answer 1

在您的示例中，可以只使用for-each循环：

private void waitForCompletion(List<Future<HttpResponse>> futureList) {
    for(Future<HttpReponse> future:futureList) {
        try {
            future.get();
        } catch (InterruptedException | ExecutionException e) {
            LOG.error("Something went wrong: ", e);
        }
    }
}

注意:ArrayList#Get不支持fail-fast特性，因此第二种方法与第一种方法不同。

fail-fast：如果在创建迭代器之后的任何时候以任何方式（除了通过迭代器自己的remove或add方法之外）对列表进行结构化修改，迭代器将抛出一个ConcurrentModificationException。因此，在面对并发修改时，迭代器会迅速而干净地失败，而不是冒着在未来某个未定时间任意、非确定性行为的风险。

List<Integer> list = new ArrayList<Integer>();
list.add(1);
Iterator<Integer> it = list.iterator();

it.next(); // return 1;

list.add(2);// the list is modified 
it.next();
// ^--- fail-fast throws a ConcurrentModificationException

private void waitForCompletion(List<Future<HttpResponse>> futureList)
                                                   throws Exception {
    for(Future<HttpReponse> future:futureList) {
         future.get();
    }
}

另一个不同的地方是数组#foreach只创建一次lambda表达式实例。但是for-each循环将为每个调用创建一个新的迭代器，例如：

void forEachLoop(){
  //          v--- create a new Iterator when forEachLoop was called.
  for(T item:items);
}

void forEach(){
                // v--- create a single lambda instance.
  items.forEach(it->{});
}