blocks|key|3002718|text|你已经回答了你的额外问题:不，使用增强的for循环是不安全的-因为它使用了迭代器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3002719|至于哪种方法是最合适的-这实际上取决于你的上下文：|3002720|3002721|是不是很少写入？如果是这样的话，CopyOnWriteArrayList可能是最appropriate.|unordered-list-item|offset|length|style|CODE|3002722|Is的集合合理的小，并且迭代快？(例如，你在循环中没有做太多的工作)如果是这样，同步可能很好-特别是如果这种情况不经常发生的话(例如，你不会有太多的collection).|3002723|If争用你正在做大量的工作，并且不想在同一时间阻止其他线程工作，克隆集合的成功可能是可以接受的。|3002724|3002725|entityMap^0|0|0|0|G|K|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|V|8|@$H|W|I|X|J|K]]|9|@]|A|$]]|$1|L|3|M|5|G|7|Y|8|@]|9|@]|A|$]]|$1|N|3|O|5|G|7|Z|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

You've already answered your bonus question really: no, using an enhanced for loop isn't safe - because it uses an iterator.

As for which is the most appropriate approach - it really depends on how your context:

<ul>
<li>Are writes very infrequent? If so, <code>CopyOnWriteArrayList</code> may be most appropriate.</li>
<li>Is the collection reasonably small, and the iteration quick? (i.e. you're not doing much work in the loop) If so, synchronizing may well be fine - especially if this doesn't happen too often (i.e. you won't have much contention for the collection).</li>
<li>If you're doing a lot of work and don't want to block other threads working at the same time, the hit of cloning the collection may well be acceptable.</li>
</ul>

blocks|key|3216015|text|取决于您的访问模型。如果您的并发较低且写入频率较高，则1的性能最佳。如果您有高并发和不频繁的写入，3将具有最佳性能。选项2在几乎所有情况下都会表现不佳。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3216016|foreach调用iterator()，因此完全相同的事情也适用。|offset|length|style|CODE|3216017|entityMap^0|0|0|7|9|A|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

Depends on your access model. If you have low concurrency and frequent writes, 1 will have the best performance. If you have high concurrency with and infrequent writes, 3 will have the best performance. Option 2 is going to perform badly in almost all cases.

<code>foreach</code> calls <code>iterator()</code>, so exactly the same things apply.

blocks|key|287726|text|您可以使用Java5.0中添加的较新的集合之一，该集合支持在迭代时进行并发访问。另一种方法是使用toArray进行复制，这是线程安全的(在复制期间)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|287727|Collection<String>+words+=+...
//+enhanced+for+loop+over+an+array.
for(String+word:+words.toArray(new+String[0]))+{

}|code-block|syntax|javascript|287728|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You could use one of the newer collections added in Java 5.0 which support concurrent access while iterating. Another approach is to take a copy using toArray which is thread safe (during the copy).

<pre><code>Collection&lt;String&gt; words = ...
// enhanced for loop over an array.
for(String word: words.toArray(new String[0])) {

}
</code></pre>

blocks|key|286802|text|我可能完全不同意你的需求，但是如果你没有意识到这些需求，请查看google-collections，并牢记“偏好不变性”。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|286803|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/p/google-collections/^0|V|I|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I might be totally off with your requirements, but if you are not aware of them, check out <a href="http://code.google.com/p/google-collections/" rel="nofollow">google-collections</a> with "Favor immutability" in mind.

blocks|key|3216039|text|我建议删除Collections.synchronizedXXX，并在客户端代码中统一处理所有锁定。基本集合不支持线程代码中有用的复合操作，即使使用java.util.concurrent.*，代码也会更加困难。我建议尽可能多地保持代码与线程无关。将困难和容易出错的线程安全代码(如果我们非常幸运的话)保持在最低限度。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3216040|entityMap^0|5|R|22|M|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

I suggest dropping <code>Collections.synchronizedXXX</code> and handle all locking uniformly in the client code. The basic collections don't support the sort of compound operations useful in threaded code, and even if you use <code>java.util.concurrent.*</code> the code is more difficult. I suggest keeping as much code as possible thread-agnostic. Keep difficult and error-prone thread-safe (if we are very lucky) code to a minimum.

blocks|key|286868|text|这三个选项都会起作用。为你的情况选择正确的选择将取决于你的情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|286869|如果您想要一个列表实现，并且您不介意每次写入时底层存储被复制，那么CopyOnWriteArrayList将会起作用。只要你没有非常大的集合，这对于性能来说是非常好的。|offset|length|style|CODE|286870|如果你需要一个Map或Set接口，ConcurrentHashMap或"ConcurrentHashSet“(使用Collections.newSetFromMap)就可以工作，显然你不能通过这种方式获得随机访问。一个很棒！这两种方法都能很好地处理大型数据集--当它们发生变异时，它们只会复制底层数据存储的一小部分。|286871|entityMap^0|0|X|K|0|7|3|B|3|H|H|10|H|1L|P|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|K|$]]

All three of your options will work. Choosing the right one for your situation will depend on what your situation is.

<code>CopyOnWriteArrayList</code> will work if you want a list implementation and you don't mind the underlying storage being copied every time you write. This is pretty good for performance as long as you don't have very big collections.

<code>ConcurrentHashMap</code> or "<code>ConcurrentHashSet</code>" (using <code>Collections.newSetFromMap</code>) will work if you need a <code>Map</code> or <code>Set</code> interface, obviously you don't get random access this way. One great! thing about these two is that they will work well with large data sets - when mutated they just copy little bits of the underlying data storage.

blocks|key|3002783|text|它确实取决于实现克隆/复制/toArray()、新的ArrayList(..)并且likes获得快照并且不锁定该集合。使用同步(集合)和迭代，确保在迭代结束时不做任何修改，即有效地锁定它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3002784|附注：(在内部需要创建临时ArrayList时，通常首选toArray()，但有一些例外)。还请注意，除了toArray()之外的任何东西都应该包装在使用Collections.synchronizedXXX提供的synchronized(集合)中。|3002785|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

It does depend on the result one needs to achieve cloning/copying/toArray(), new ArrayList(..) and the likes obtain a snapshot and does not lock the the collection.
Using synchronized(collection) and iteration through ensure by the end of the iteration would be no modification, i.e. effectively locking it.

side note:(toArray() is usually preferred with some exceptions when internally it needs to create a temporary ArrayList). Also please note, anything but toArray() should be wrapped in synchronized(collection) as well, provided using Collections.synchronizedXXX.

blocks|key|286880|text|这个问题太老了(对不起，我来晚了。)但我还是想补充一下我的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|286881|我会选择你的第二个选择(即在调用iterator()之前克隆集合)，但有一个主要的变化。|286882|例如，你想使用迭代器进行迭代，你不必在调用.iterator()之前复制集合，也不必在某种程度上否定(我粗略地使用术语“否定”)迭代器模式的思想，但你可以编写一个"ThreadSafeIterator“。|286883|它将在相同的前提下工作，复制Collection，但不会让迭代类知道您就是这么做的。这样的迭代器可能如下所示：|286884|class+ThreadSafeIterator<T>+implements+Iterator<T>+{
++++private+final+Queue<T>+clients;
++++private+T+currentElement;
++++private+final+Collection<T>+source;

++++AsynchronousIterator(final+Collection<T>+collection)+{
++++++++clients+=+new+LinkedList<>(collection);
++++++++this.source+=+collection;
++++}

++++@Override
++++public+boolean+hasNext()+{
++++++++return+clients.peek()+!=+null;
++++}

++++@Override
++++public+T+next()+{
++++++++currentElement+=+clients.poll();
++++++++return+currentElement;
++++}

++++@Override
++++public+void+remove()+{
++++++++synchronized(source)+{
++++++++++++source.remove(currentElement);
++++++++}
++++}
}|code-block|syntax|javascript|286885|更进一步，您可以使用Semaphore类来确保线程安全之类的。但对remove方法持保留态度。|offset|length|style|CODE|286886|重点是，通过使用这样的迭代器，没有人，无论是迭代者还是迭代类(这是一个真正的词)都不必担心线程的安全性。|286887|entityMap^0|0|0|0|0|0|A|9|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|11|8|@$O|12|P|13|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

This Question is rather old (sorry, i am a bit late..) but i still want to add my Answer.

I would choose your second choice (i.e. Clone the collection before calling iterator()) but with a major twist.

Asuming, you want to iterate using iterator, you do not have to coppy the Collection before calling .iterator() and sort of negating (i am using the term "negating" loosely) the idea of the iterator pattern, but you could write a "ThreadSafeIterator".

It would work on the same premise, coppying the Collection, but without letting the iterating class know, that you did just that. Such an Iterator might look like this:

<pre><code>class ThreadSafeIterator&lt;T&gt; implements Iterator&lt;T&gt; {
 private final Queue&lt;T&gt; clients;
 private T currentElement;
 private final Collection&lt;T&gt; source;

 AsynchronousIterator(final Collection&lt;T&gt; collection) {
 clients = new LinkedList&lt;&gt;(collection);
 this.source = collection;
 }

 @Override
 public boolean hasNext() {
 return clients.peek() != null;
 }

 @Override
 public T next() {
 currentElement = clients.poll();
 return currentElement;
 }

 @Override
 public void remove() {
 synchronized(source) {
 source.remove(currentElement);
 }
 }
}
</code></pre>

Taking this a Step furhter, you might use the <code>Semaphore</code> Class to ensure thread-safety or something. But take the remove method with a grain of salt.

The point is, by using such an Iterator, no one, neither the iterating nor the iterated Class (is that a real word) has to worrie about Thread safety.

We all know when using <code>Collections.synchronizedXXX</code> (e.g. <code>synchronizedSet()</code>) we get a synchronized "view" of the underlying collection.

However, the document of these wrapper generation methods states that we have to explicitly synchronize on the collection when iterating of the collections using an iterator.

Which option do you choose to solve this problem? 

I can only see the following approaches:

<ol>
<li>Do it as the documentation states: synchronize on the collection</li>
<li>Clone the collection before calling <code>iterator()</code></li>
<li>Use a collection which iterator is thread-safe (I am only aware of <code>CopyOnWriteArrayList</code>/Set)</li>
</ol>

And as a bonus question: when using a synchronized view - is the use of foreach/Iterable thread-safe?

Thread-safe iteration over a collection

数据存储

我们都知道，当使用Collections.synchronizedXXX (例如synchronizedSet())时，我们会得到底层集合的同步“视图”。然而，这些包装器生成方法的文档指出，当使用迭代器迭代集合时，我们必须在集合上显式同步。您选择哪个选项来解决此问题？我只看到以下几种方法：在调用iterator()Use集合之前，先在collectionClone上同步集合，该迭代器是线程安全的(

问集合上的线程安全迭代
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问集合上的线程安全迭代EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问集合上的线程安全迭代
EN