ArrayList(Collection<? extends E> c) 线程安全吗？

Question

假设sourceCollection 是同步的，通过构造函数ArrayList(Collection<? extends E> sourceCollection) 创建ArrayList 的新实例是否线程安全？更具体地说，在这种情况下，我们能否依靠新列表准确包含调用 new ArrayList(sourceCollection) 时集合中的元素？我们可以依靠新列表保持一致状态吗？

我问这个问题是因为我在有关如何将对象限制到线程堆栈上的局部变量的并发书籍中看到了示例。在这些示例中，一个方法被传递一个对共享对象的引用，并且在该方法内部，该对象的一个​​副本存储在一个局部变量中——所有这些都没有任何同步。据称可以通过这种方式实现线程安全。一个一般的例子是：

public void someMethod(Collection<String> source) {
    List<String> localList = new ArrayList<>(source);
    ...
}

Answer 1

提示：正如@John Bollinger 刚刚提到的，特定的ArrayList 实现不在语言规范中。所以下面写的对于 Oracle java 8 实现是正确的。

---

是的，如果source是同步收集是安全的，因为在这种情况下ArrayList构造函数使用源收集的toArray()方法，它也被同步并产生新的数据副本：

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    // ...
}

Answer 2

您的具体问题的答案就是问题的答案 - 源收集线程安全吗？

尝试了解我们如何到达那里的最佳方式是找到源头。

以ArrayList开头

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
        size = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

深入了解Collection.toArray 的文档

/**
 * Returns an array containing all of the elements in this collection.
 * If this collection makes any guarantees as to what order its elements
 * are returned by its iterator, this method must return the elements in
 * the same order.
 *
 * <p>The returned array will be "safe" in that no references to it are
 * maintained by this collection.  (In other words, this method must
 * allocate a new array even if this collection is backed by an array).
 * The caller is thus free to modify the returned array.
 *
 * <p>This method acts as bridge between array-based and collection-based
 * APIs.
 *
 * @return an array containing all of the elements in this collection
 */
Object[] toArray();

返回ArrayList.toArray（假设源集合运行时类型是一个ArrayList）

/**
 * Returns an array containing all of the elements in this list
 * in proper sequence (from first to last element).
 *
 * <p>The returned array will be "safe" in that no references to it are
 * maintained by this list.  (In other words, this method must allocate
 * a new array).  The caller is thus free to modify the returned array.
 *
 * <p>This method acts as bridge between array-based and collection-based
 * APIs.
 *
 * @return an array containing all of the elements in this list in
 *         proper sequence
 */
public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

最后到Array.copyOf

/**
 * Copies the specified array, truncating or padding with nulls (if necessary)
 * so the copy has the specified length.  For all indices that are
 * valid in both the original array and the copy, the two arrays will
 * contain identical values.  For any indices that are valid in the
 * copy but not the original, the copy will contain <tt>null</tt>.
 * Such indices will exist if and only if the specified length
 * is greater than that of the original array.
 * The resulting array is of the class <tt>newType</tt>.
 *
 * @param <U> the class of the objects in the original array
 * @param <T> the class of the objects in the returned array
 * @param original the array to be copied
 * @param newLength the length of the copy to be returned
 * @param newType the class of the copy to be returned
 * @return a copy of the original array, truncated or padded with nulls
 *     to obtain the specified length
 * @throws NegativeArraySizeException if <tt>newLength</tt> is negative
 * @throws NullPointerException if <tt>original</tt> is null
 * @throws ArrayStoreException if an element copied from
 *     <tt>original</tt> is not of a runtime type that can be stored in
 *     an array of class <tt>newType</tt>
 * @since 1.6
 */
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

System.arraycopy 是本机方法。在其调用堆栈顶部对c.toArray 的调用使用System.arraycopy，这是一种未记录为线程安全的本机方法。

回到堆栈，您的具体问题的答案就是问题的答案 - 源收集线程安全吗？

如果您使用 ArrayList 作为源集合，则需要确保代码中的线程安全。