Is iterating ConcurrentHashMap values thread safe

Question

In javadoc for ConcurrentHashMap is the following      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    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

User · Answer

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

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++)
    {
      map.put("key" + 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() + " - [" + entry.getKey() + ", " + entry.getValue() + ']'
        );
      }
    }
  }

  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++)
      {
        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);
  }
}

No exception will be thrown.

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

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++)
    {
      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<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() + " - [" + entry.getKey() + ", " + entry.getValue() + ']';
        } 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++)
      {
        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);
  }
}

As soon as you start sharing the same Iterator<Map.Entry<String, String>> among accessor and mutator threads java.lang.IllegalStateExceptions will start popping up.

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++)
    {
      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<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() + " - [" + entry.getKey() + ", " + entry.getValue() + ']';
        } 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" + 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);
  }
}

User · Answer

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

User · Answer

This might give you a good insight      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    Regarding this      However  iterators are designed to be used by only one thread at a time    It means  while using iterators produced by ConcurrentHashMap in two threads are safe  it may cause an unexpected result in the application

User · Answer

What does it mean    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      What happens if I try to iterate the map with two threads at the same time     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      What happens if I put or remove a value from the map while iterating it    That s a separate issue  but the javadoc section that you quoted adequately answers it   Basically  the iterators are thread-safe  but it is not defined whether you will see the effects of any concurrent insertions  updates or deletions reflected in the sequence of objects returned by the iterator   In practice  it probably depends on where in the map the updates occur

User · Answer

What does it mean    That means that each iterator you obtain from a ConcurrentHashMap 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      What happens if I try to iterate the map with two threads at the same time    It will work as expected if each of the threads uses it s own iterator       What happens if I put or remove a value from the map while iterating it    It is guaranteed that things will not break if you do this  that s part of what the  concurrent  in ConcurrentHashMap 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  for  Object o   someConcurrentHashMap entrySet                     will be fine  or at least safe  almost every time you see it

[java] Is iterating ConcurrentHashMap values thread safe?

Examples related to java

Examples related to multithreading

Examples related to concurrency

Examples related to thread-safety

Examples related to concurrenthashmap