blocks|key|298918|text|This可能会给你一个很好的洞察力|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|298919|298920|+ConcurrentHashMap通过略微放松对调用者的承诺来实现更高的并发性。检索操作将返回由最近完成的插入操作插入的值，也可以返回由并发进行的插入操作添加的值(但在任何情况下，它都不会返回无意义的结果)。由ConcurrentHashMap.iterator()返回的迭代器最多返回每个元素一次，并且永远不会抛出ConcurrentModificationException，但是可能会也可能不会反映自迭代器被构造为以来发生的插入或删除。在迭代集合时，不需要(甚至不可能)表范围的锁来提供线程安全性。在任何不需要锁定整个表来阻止更新的应用程序中，ConcurrentHashMap都可以用作synchronizedMap或哈希表的替代品。|blockquote|style|BOLD|298921|298922|298923|关于这一点：|298924|298925|然而，迭代器被设计为一次只能由一个线程使用。|298926|298927|298928|这意味着，虽然在两个线程中使用ConcurrentHashMap生成的迭代器是安全的，但它可能会在应用程序中导致意外的结果。|298929|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ibm.com/developerworks/java/library/j-jtp07233.html^0|0|4|0|0|0|3T|22|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|-4|5|6|7|16|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|17|8|@$A|18|B|19|H|I]]|9|@]|C|$]]|$1|J|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|1C|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]|$1|O|3|P|5|G|7|1E|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]|$1|R|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1H|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1I|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]]]

<a href="http://www.ibm.com/developerworks/java/library/j-jtp07233.html" rel="noreferrer">This</a> might give you a good insight 

<blockquote>
 ConcurrentHashMap achieves higher concurrency by slightly relaxing the promises it makes to callers. A retrieval operation will return the value inserted by the most recent completed insert operation, and may also return a value added by an insertion operation that is concurrently in progress (but in no case will it return a nonsense result). Iterators returned by ConcurrentHashMap.iterator() will return each element once at most and will not ever throw ConcurrentModificationException, but may or may not reflect insertions or removals that occurred since the iterator was constructed. No table-wide locking is needed (or even possible) to provide thread-safety when iterating the collection. ConcurrentHashMap may be used as a replacement for synchronizedMap or Hashtable in any application that does not rely on the ability to lock the entire table to prevent updates.
</blockquote>

Regarding this:

<blockquote>
 However, iterators are designed to be used by only one thread at a time.
</blockquote>

It means, while using iterators produced by ConcurrentHashMap in two threads are safe, it may cause an unexpected result in the application.

blocks|key|3020779|text|这意味着您不应该在多个线程之间共享迭代器对象。创建多个迭代器并在单独的线程中并发使用它们是很好的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3020780|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It means that you should not share an iterator object among multiple threads. Creating multiple iterators and using them concurrently in separate threads is fine.

blocks|key|298945|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|298946|这是什么意思？|blockquote|298947|298948|298949|这意味着从ConcurrentHashMap获得的每个迭代器都被设计为供单个线程使用，不应该到处传递。这包括for-each循环提供的语法糖。|offset|length|style|CODE|298950|298951|如果我试图同时用两个线程迭代映射，会发生什么？|298952|298953|298954|如果每个线程都使用自己的迭代器，那么它将按预期工作。|298955|298956|如果我在迭代映射时放入或删除一个值，会发生什么？|298957|298958|298959|如果这样做，可以保证不会中断(这是ConcurrentHashMap中“并发”的一部分意思)。但是，不能保证一个线程将看到另一个线程执行的映射的更改(不从映射中获取新的迭代器)。迭代器保证反映映射在创建时的状态。进一步的更改可能会反映在迭代器中，但它们不是必须的。|298960|总之，像这样的语句|298961|for+(Object+o+:+someConcurrentHashMap.entrySet())+{
++++//+...
}|code-block|syntax|javascript|298962|几乎每次你看到它都会很好(或者至少是安全的)。|298963|entityMap^0|0|0|0|0|5|H|0|0|0|0|0|0|0|0|0|0|H|H|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|1A|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1B|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1C|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1D|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|1E|7|@$H|1F|I|1G|J|K]]|8|@]|9|$]]|$1|L|3|-4|4|5|6|1H|7|@]|8|@]|9|$]]|$1|M|3|N|4|C|6|1I|7|@]|8|@]|9|$]]|$1|O|3|-4|4|5|6|1J|7|@]|8|@]|9|$]]|$1|P|3|-4|4|5|6|1K|7|@]|8|@]|9|$]]|$1|Q|3|R|4|5|6|1L|7|@]|8|@]|9|$]]|$1|S|3|-4|4|5|6|1M|7|@]|8|@]|9|$]]|$1|T|3|U|4|C|6|1N|7|@]|8|@]|9|$]]|$1|V|3|-4|4|5|6|1O|7|@]|8|@]|9|$]]|$1|W|3|-4|4|5|6|1P|7|@]|8|@]|9|$]]|$1|X|3|Y|4|5|6|1Q|7|@$H|1R|I|1S|J|K]]|8|@]|9|$]]|$1|Z|3|10|4|5|6|1T|7|@]|8|@]|9|$]]|$1|11|3|12|4|13|6|1U|7|@]|8|@]|9|$14|15]]|$1|16|3|17|4|5|6|1V|7|@]|8|@]|9|$]]|$1|18|3|-4|4|5|6|1W|7|@]|8|@]|9|$]]]|19|$]]

<blockquote>
 What does it mean?
</blockquote>

That means that each iterator you obtain from a <code>ConcurrentHashMap</code> is designed to be used by a single thread and should not be passed around. This includes the syntactic sugar that the for-each loop provides.

<blockquote>
 What happens if I try to iterate the map with two threads at the same time?
</blockquote>

It will work as expected if each of the threads uses it's own iterator. 

<blockquote>
 What happens if I put or remove a value from the map while iterating it?
</blockquote>

It is guaranteed that things will not break if you do this (that's part of what the "concurrent" in <code>ConcurrentHashMap</code> means). However, there is no guarantee that one thread will see the changes to the map that the other thread performs (without obtaining a new iterator from the map). The iterator is guaranteed to reflect the state of the map at the time of it's creation. Futher changes may be reflected in the iterator, but they do not have to be.

In conclusion, a statement like

<pre><code>for (Object o : someConcurrentHashMap.entrySet()) {
 // ...
}
</code></pre>

will be fine (or at least safe) almost every time you see it.

blocks|key|296374|text|您可以使用这个类来测试两个访问线程和一个改变ConcurrentHashMap共享实例的线程|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|296375|import+java.util.Map;
import+java.util.Random;
import+java.util.UUID;
import+java.util.concurrent.ConcurrentHashMap;
import+java.util.concurrent.ExecutorService;
import+java.util.concurrent.Executors;

public+class+ConcurrentMapIteration
{
++private+final+Map<String,+String>+map+=+new+ConcurrentHashMap<String,+String>();

++private+final+static+int+MAP_SIZE+=+100000;

++public+static+void+main(String[]+args)
++{
++++new+ConcurrentMapIteration().run();
++}

++public+ConcurrentMapIteration()
++{
++++for+(int+i+=+0;+i+<+MAP_SIZE;+i%2B%2B)
++++{
++++++map.put("key"+%2B+i,+UUID.randomUUID().toString());
++++}
++}

++private+final+ExecutorService+executor+=+Executors.newCachedThreadPool();

++private+final+class+Accessor+implements+Runnable
++{
++++private+final+Map<String,+String>+map;

++++public+Accessor(Map<String,+String>+map)
++++{
++++++this.map+=+map;
++++}

++++@Override
++++public+void+run()
++++{
++++++for+(Map.Entry<String,+String>+entry+:+this.map.entrySet())
++++++{
++++++++System.out.println(
++++++++++++Thread.currentThread().getName()+%2B+"+-+["+%2B+entry.getKey()+%2B+",+"+%2B+entry.getValue()+%2B+']'
++++++++);
++++++}
++++}
++}

++private+final+class+Mutator+implements+Runnable
++{

++++private+final+Map<String,+String>+map;
++++private+final+Random+random+=+new+Random();

++++public+Mutator(Map<String,+String>+map)
++++{
++++++this.map+=+map;
++++}

++++@Override
++++public+void+run()
++++{
++++++for+(int+i+=+0;+i+<+100;+i%2B%2B)
++++++{
++++++++this.map.remove("key"+%2B+random.nextInt(MAP_SIZE));
++++++++this.map.put("key"+%2B+random.nextInt(MAP_SIZE),+UUID.randomUUID().toString());
++++++++System.out.println(Thread.currentThread().getName()+%2B+":+"+%2B+i);
++++++}
++++}
++}

++private+void+run()
++{
++++Accessor+a1+=+new+Accessor(this.map);
++++Accessor+a2+=+new+Accessor(this.map);
++++Mutator+m+=+new+Mutator(this.map);

++++executor.execute(a1);
++++executor.execute(m);
++++executor.execute(a2);
++}
}|code-block|syntax|javascript|296376|不会抛出异常。|296377|在访问器线程之间共享相同的迭代器可能会导致死锁：|296378|import+java.util.Iterator;
import+java.util.Map;
import+java.util.Random;
import+java.util.UUID;
import+java.util.concurrent.ConcurrentHashMap;
import+java.util.concurrent.ExecutorService;
import+java.util.concurrent.Executors;

public+class+ConcurrentMapIteration
{
++private+final+Map<String,+String>+map+=+new+ConcurrentHashMap<String,+String>();
++private+final+Iterator<Map.Entry<String,+String>>+iterator;

++private+final+static+int+MAP_SIZE+=+100000;

++public+static+void+main(String[]+args)
++{
++++new+ConcurrentMapIteration().run();
++}

++public+ConcurrentMapIteration()
++{
++++for+(int+i+=+0;+i+<+MAP_SIZE;+i%2B%2B)
++++{
++++++map.put("key"+%2B+i,+UUID.randomUUID().toString());
++++}
++++this.iterator+=+this.map.entrySet().iterator();
++}

++private+final+ExecutorService+executor+=+Executors.newCachedThreadPool();

++private+final+class+Accessor+implements+Runnable
++{
++++private+final+Iterator<Map.Entry<String,+String>>+iterator;

++++public+Accessor(Iterator<Map.Entry<String,+String>>+iterator)
++++{
++++++this.iterator+=+iterator;
++++}

++++@Override
++++public+void+run()
++++{
++++++while(iterator.hasNext())+{
++++++++Map.Entry<String,+String>+entry+=+iterator.next();
++++++++try
++++++++{
++++++++++String+st+=+Thread.currentThread().getName()+%2B+"+-+["+%2B+entry.getKey()+%2B+",+"+%2B+entry.getValue()+%2B+']';
++++++++}+catch+(Exception+e)
++++++++{
++++++++++e.printStackTrace();
++++++++}

++++++}
++++}
++}

++private+final+class+Mutator+implements+Runnable
++{

++++private+final+Map<String,+String>+map;
++++private+final+Random+random+=+new+Random();

++++public+Mutator(Map<String,+String>+map)
++++{
++++++this.map+=+map;
++++}

++++@Override
++++public+void+run()
++++{
++++++for+(int+i+=+0;+i+<+100;+i%2B%2B)
++++++{
++++++++this.map.remove("key"+%2B+random.nextInt(MAP_SIZE));
++++++++this.map.put("key"+%2B+random.nextInt(MAP_SIZE),+UUID.randomUUID().toString());
++++++}
++++}
++}

++private+void+run()
++{
++++Accessor+a1+=+new+Accessor(this.iterator);
++++Accessor+a2+=+new+Accessor(this.iterator);
++++Mutator+m+=+new+Mutator(this.map);

++++executor.execute(a1);
++++executor.execute(m);
++++executor.execute(a2);
++}
}|296379|一旦你开始在存取器和赋值器线程之间共享相同的Iterator<Map.Entry<String,+String>>，java.lang.IllegalStateException就会开始弹出。|296380|import+java.util.Iterator;
import+java.util.Map;
import+java.util.Random;
import+java.util.UUID;
import+java.util.concurrent.ConcurrentHashMap;
import+java.util.concurrent.ExecutorService;
import+java.util.concurrent.Executors;

public+class+ConcurrentMapIteration
{
++private+final+Map<String,+String>+map+=+new+ConcurrentHashMap<String,+String>();
++private+final+Iterator<Map.Entry<String,+String>>+iterator;

++private+final+static+int+MAP_SIZE+=+100000;

++public+static+void+main(String[]+args)
++{
++++new+ConcurrentMapIteration().run();
++}

++public+ConcurrentMapIteration()
++{
++++for+(int+i+=+0;+i+<+MAP_SIZE;+i%2B%2B)
++++{
++++++map.put("key"+%2B+i,+UUID.randomUUID().toString());
++++}
++++this.iterator+=+this.map.entrySet().iterator();
++}

++private+final+ExecutorService+executor+=+Executors.newCachedThreadPool();

++private+final+class+Accessor+implements+Runnable
++{
++++private+final+Iterator<Map.Entry<String,+String>>+iterator;

++++public+Accessor(Iterator<Map.Entry<String,+String>>+iterator)
++++{
++++++this.iterator+=+iterator;
++++}

++++@Override
++++public+void+run()
++++{
++++++while+(iterator.hasNext())
++++++{
++++++++Map.Entry<String,+String>+entry+=+iterator.next();
++++++++try
++++++++{
++++++++++String+st+=
++++++++++++++Thread.currentThread().getName()+%2B+"+-+["+%2B+entry.getKey()+%2B+",+"+%2B+entry.getValue()+%2B+']';
++++++++}+catch+(Exception+e)
++++++++{
++++++++++e.printStackTrace();
++++++++}

++++++}
++++}
++}

++private+final+class+Mutator+implements+Runnable
++{

++++private+final+Random+random+=+new+Random();

++++private+final+Iterator<Map.Entry<String,+String>>+iterator;

++++private+final+Map<String,+String>+map;

++++public+Mutator(Map<String,+String>+map,+Iterator<Map.Entry<String,+String>>+iterator)
++++{
++++++this.map+=+map;
++++++this.iterator+=+iterator;
++++}

++++@Override
++++public+void+run()
++++{
++++++while+(iterator.hasNext())
++++++{
++++++++try
++++++++{
++++++++++iterator.remove();
++++++++++this.map.put("key"+%2B+random.nextInt(MAP_SIZE),+UUID.randomUUID().toString());
++++++++}+catch+(Exception+ex)
++++++++{
++++++++++ex.printStackTrace();
++++++++}
++++++}

++++}
++}

++private+void+run()
++{
++++Accessor+a1+=+new+Accessor(this.iterator);
++++Accessor+a2+=+new+Accessor(this.iterator);
++++Mutator+m+=+new+Mutator(map,+this.iterator);

++++executor.execute(a1);
++++executor.execute(m);
++++executor.execute(a2);
++}
}|296381|entityMap^0|M|H|0|0|0|0|0|M|Z|1M|V|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|S|3|T|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|U|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|V|$]]

You may use this class to test two accessing threads and one mutating the shared instance of <code>ConcurrentHashMap</code>:

<pre><code>import java.util.Map;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrentMapIteration
{
 private final Map&lt;String, String&gt; map = new ConcurrentHashMap&lt;String, String&gt;();

 private final static int MAP_SIZE = 100000;

 public static void main(String[] args)
 {
 new ConcurrentMapIteration().run();
 }

 public ConcurrentMapIteration()
 {
 for (int i = 0; i &lt; MAP_SIZE; i++)
 {
 map.put("key" + i, UUID.randomUUID().toString());
 }
 }

 private final ExecutorService executor = Executors.newCachedThreadPool();

 private final class Accessor implements Runnable
 {
 private final Map&lt;String, String&gt; map;

 public Accessor(Map&lt;String, String&gt; map)
 {
 this.map = map;
 }

 @Override
 public void run()
 {
 for (Map.Entry&lt;String, String&gt; entry : this.map.entrySet())
 {
 System.out.println(
 Thread.currentThread().getName() + " - [" + entry.getKey() + ", " + entry.getValue() + ']'
 );
 }
 }
 }

 private final class Mutator implements Runnable
 {

 private final Map&lt;String, String&gt; map;
 private final Random random = new Random();

 public Mutator(Map&lt;String, String&gt; map)
 {
 this.map = map;
 }

 @Override
 public void run()
 {
 for (int i = 0; i &lt; 100; i++)
 {
 this.map.remove("key" + random.nextInt(MAP_SIZE));
 this.map.put("key" + random.nextInt(MAP_SIZE), UUID.randomUUID().toString());
 System.out.println(Thread.currentThread().getName() + ": " + i);
 }
 }
 }

 private void run()
 {
 Accessor a1 = new Accessor(this.map);
 Accessor a2 = new Accessor(this.map);
 Mutator m = new Mutator(this.map);

 executor.execute(a1);
 executor.execute(m);
 executor.execute(a2);
 }
}
</code></pre>

No exception will be thrown.

Sharing the same iterator between accessor threads can lead to deadlock:

<pre><code>import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrentMapIteration
{
 private final Map&lt;String, String&gt; map = new ConcurrentHashMap&lt;String, String&gt;();
 private final Iterator&lt;Map.Entry&lt;String, String&gt;&gt; iterator;

 private final static int MAP_SIZE = 100000;

 public static void main(String[] args)
 {
 new ConcurrentMapIteration().run();
 }

 public ConcurrentMapIteration()
 {
 for (int i = 0; i &lt; MAP_SIZE; i++)
 {
 map.put("key" + i, UUID.randomUUID().toString());
 }
 this.iterator = this.map.entrySet().iterator();
 }

 private final ExecutorService executor = Executors.newCachedThreadPool();

 private final class Accessor implements Runnable
 {
 private final Iterator&lt;Map.Entry&lt;String, String&gt;&gt; iterator;

 public Accessor(Iterator&lt;Map.Entry&lt;String, String&gt;&gt; iterator)
 {
 this.iterator = iterator;
 }

 @Override
 public void run()
 {
 while(iterator.hasNext()) {
 Map.Entry&lt;String, String&gt; entry = iterator.next();
 try
 {
 String st = Thread.currentThread().getName() + " - [" + entry.getKey() + ", " + entry.getValue() + ']';
 } catch (Exception e)
 {
 e.printStackTrace();
 }

 }
 }
 }

 private final class Mutator implements Runnable
 {

 private final Map&lt;String, String&gt; map;
 private final Random random = new Random();

 public Mutator(Map&lt;String, String&gt; map)
 {
 this.map = map;
 }

 @Override
 public void run()
 {
 for (int i = 0; i &lt; 100; i++)
 {
 this.map.remove("key" + random.nextInt(MAP_SIZE));
 this.map.put("key" + random.nextInt(MAP_SIZE), UUID.randomUUID().toString());
 }
 }
 }

 private void run()
 {
 Accessor a1 = new Accessor(this.iterator);
 Accessor a2 = new Accessor(this.iterator);
 Mutator m = new Mutator(this.map);

 executor.execute(a1);
 executor.execute(m);
 executor.execute(a2);
 }
}
</code></pre>

As soon as you start sharing the same <code>Iterator&lt;Map.Entry&lt;String, String&gt;&gt;</code> among accessor and mutator threads <code>java.lang.IllegalStateException</code>s will start popping up.

<pre><code>import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrentMapIteration
{
 private final Map&lt;String, String&gt; map = new ConcurrentHashMap&lt;String, String&gt;();
 private final Iterator&lt;Map.Entry&lt;String, String&gt;&gt; iterator;

 private final static int MAP_SIZE = 100000;

 public static void main(String[] args)
 {
 new ConcurrentMapIteration().run();
 }

 public ConcurrentMapIteration()
 {
 for (int i = 0; i &lt; MAP_SIZE; i++)
 {
 map.put("key" + i, UUID.randomUUID().toString());
 }
 this.iterator = this.map.entrySet().iterator();
 }

 private final ExecutorService executor = Executors.newCachedThreadPool();

 private final class Accessor implements Runnable
 {
 private final Iterator&lt;Map.Entry&lt;String, String&gt;&gt; iterator;

 public Accessor(Iterator&lt;Map.Entry&lt;String, String&gt;&gt; iterator)
 {
 this.iterator = iterator;
 }

 @Override
 public void run()
 {
 while (iterator.hasNext())
 {
 Map.Entry&lt;String, String&gt; entry = iterator.next();
 try
 {
 String st =
 Thread.currentThread().getName() + " - [" + entry.getKey() + ", " + entry.getValue() + ']';
 } catch (Exception e)
 {
 e.printStackTrace();
 }

 }
 }
 }

 private final class Mutator implements Runnable
 {

 private final Random random = new Random();

 private final Iterator&lt;Map.Entry&lt;String, String&gt;&gt; iterator;

 private final Map&lt;String, String&gt; map;

 public Mutator(Map&lt;String, String&gt; map, Iterator&lt;Map.Entry&lt;String, String&gt;&gt; iterator)
 {
 this.map = map;
 this.iterator = iterator;
 }

 @Override
 public void run()
 {
 while (iterator.hasNext())
 {
 try
 {
 iterator.remove();
 this.map.put("key" + random.nextInt(MAP_SIZE), UUID.randomUUID().toString());
 } catch (Exception ex)
 {
 ex.printStackTrace();
 }
 }

 }
 }

 private void run()
 {
 Accessor a1 = new Accessor(this.iterator);
 Accessor a2 = new Accessor(this.iterator);
 Mutator m = new Mutator(map, this.iterator);

 executor.execute(a1);
 executor.execute(m);
 executor.execute(a2);
 }
}
</code></pre>

blocks|key|3235275|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3235276|这是什么意思？|blockquote|3235277|3235278|3235279|这意味着您不应该尝试在两个线程中使用相同的迭代器。如果有两个线程需要遍历键、值或条目，那么它们各自都应该创建并使用自己的迭代器。|3235280|3235281|如果我试图同时用两个线程迭代映射，会发生什么？|3235282|3235283|3235284|如果你违反了这条规则，会发生什么还不是很清楚。你可能会得到令人困惑的行为，就像(例如)两个线程试图在不同步的情况下从标准输入中读取一样。你也可能得到非线程安全的行为。|3235285|但是，如果这两个线程使用不同的迭代器，那就没问题了。|3235286|3235287|如果我在迭代映射时放入或删除一个值，会发生什么？|3235288|3235289|3235290|如果两个线程使用相同的迭代器:请参见上文。你很容易产生令人困惑的，甚至可能是非线程安全的行为。|3235291|如果线程使用不同的迭代器，那么您引用的javadoc部分可以很好地回答这个问题。基本上，没有定义一个线程/迭代器是否会看到另一个线程/迭代器所做的任何并发插入、更新或删除的效果。但是，插入/更新/删除将根据映射的并发属性进行。|3235292|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|11|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|12|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|13|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|14|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|15|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|16|7|@]|8|@]|9|$]]|$1|I|3|J|4|C|6|17|7|@]|8|@]|9|$]]|$1|K|3|-4|4|5|6|18|7|@]|8|@]|9|$]]|$1|L|3|-4|4|5|6|19|7|@]|8|@]|9|$]]|$1|M|3|N|4|5|6|1A|7|@]|8|@]|9|$]]|$1|O|3|P|4|5|6|1B|7|@]|8|@]|9|$]]|$1|Q|3|-4|4|5|6|1C|7|@]|8|@]|9|$]]|$1|R|3|S|4|C|6|1D|7|@]|8|@]|9|$]]|$1|T|3|-4|4|5|6|1E|7|@]|8|@]|9|$]]|$1|U|3|-4|4|5|6|1F|7|@]|8|@]|9|$]]|$1|V|3|W|4|5|6|1G|7|@]|8|@]|9|$]]|$1|X|3|Y|4|5|6|1H|7|@]|8|@]|9|$]]|$1|Z|3|-4|4|5|6|1I|7|@]|8|@]|9|$]]]|10|$]]

<blockquote>
What does it mean?
</blockquote>
It means that you should not try to use the same iterator in two threads. If you have two threads that need to iterate over the keys, values or entries, then they each should create and use their own iterators.
<blockquote>
What happens if I try to iterate the map with two threads at the same time?
</blockquote>
It is not entirely clear what would happen if you broke this rule. You could just get confusing behavior, in the same way that you do if (for example) two threads try to read from standard input without synchronizing. You could also get non-thread-safe behavior.
But if the two threads used different iterators, you should be fine.
<blockquote>
What happens if I put or remove a value from the map while iterating it?
</blockquote>
If the two threads are using the same iterator: see above. You are liable to get confusing and possibly non-thread-safe behavior.
If the threads are using different iterators, the javadoc section that you quoted adequately answers it. Basically, it is not defined whether one thread / iterator will see the effects of any concurrent insertions, updates or deletions made by the other thread / iterator. However, the insertions / updates / deletes will be made according to the concurrency properties of the map.

In javadoc for <a href="http://download.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/ConcurrentHashMap.html" rel="noreferrer">ConcurrentHashMap</a> is the following:

<blockquote>
 Retrieval operations (including get) generally do not block, so may overlap with update operations (including put and remove). Retrievals reflect the results of the most recently completed update operations holding upon their onset. For aggregate operations such as putAll and clear, concurrent retrievals may reflect insertion or removal of only some entries. Similarly, Iterators and Enumerations return elements reflecting the state of the hash table at some point at or since the creation of the iterator/enumeration. They do not throw ConcurrentModificationException. However, iterators are designed to be used by only one thread at a time.
</blockquote>

What does it mean? What happens if I try to iterate the map with two threads at the same time? What happens if I put or remove a value from the map while iterating it?

Is iterating ConcurrentHashMap values thread safe?

在用于的javadoc中是：检索操作(包括get)一般不会阻塞，因此可能会与更新操作(包括put和remove)重叠。检索反映最近完成的更新操作的结果，这些操作在开始时保持不变。对于putAll和clear等聚合操作，并发检索可能只反映某些条目的插入或删除。类似地，迭代器和枚举返回元素，反映在迭代器/枚举创建时或之后的...

问迭代ConcurrentHashMap值是线程安全的吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问迭代ConcurrentHashMap值是线程安全的吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问迭代ConcurrentHashMap值是线程安全的吗？
EN