Different behaviours between ConcurrentSkipListMap and CopyOnWriteArrayList

[Edwardd Lee]

When I run this code:

public class CopyOnWrite {
   public static void main(String[] args){
   List<String> colors = new CopyOnWriteArrayList<>();
   colors.add("red");
   colors.add("blue");
   int i = 0;
   for (String color: colors){
       i++;
       colors.add("yellow"+i);
       System.out.print(color+" ");
       };
       System.out.println();
       System.out.println(colors);
}
}

The output is

red blue
[red, blue, yellow1, yellow2] 

, which is expected. However when I run a similar code using ConcurrentSkipListMap:

public class ConcurrentMap {
   public static void main(String[] args){
   Map<String,String> colors = new ConcurrentSkipListMap<>();
   colors.put("red", "warm");
   colors.put("blue","cold");
   int i = 0;
   for (String color: colors.keySet()){
       i++;
       colors.put("yellow"+i,"warm");
       System.out.print(color+" ");
       };
       System.out.println();
       System.out.println(colors);  
}    
}

The output is:

blue red yellow1 yellow2 yellow3 yellow4 yellow5 yellow6 yellow7 yellow8 yellow9
{blue=cold, red=warm, yellow1=warm, yellow10=warm, yellow11=warm, yellow2=warm, yellow3=warm, yellow4=warm, yellow5=warm, yellow6=warm, yellow7=warm, yellow8=warm, yellow9=warm}

which is confusing for me. I always thought that colors.keySet() in the for braces in ConcurrentSkipListMap, like colors in CopyOnWriteArrayList, was established prior to a modification and will not be updated when changes are made. In which case the output of the second code should have been:

blue red
{blue=cold, red=warm, yellow1=warm, yellow2=warm}

If it is the case that colors.keySet() is updated as soon as a modification is made, the second code should have an infinite amount of outputs, since colors.keySet() never ends being added elements into. Why then, does the actual output has a finite result?

[Henry Wong]

It is all explained in the JavaDoc... The Iterator for the sets of the ConcurrentSkipListMap are Weakly Consistent, which are further explained as...

* they may proceed concurrently with other operations
* they will never throw ConcurrentModificationException
* they are guaranteed to traverse elements as they existed upon construction exactly once, and may (but are not guaranteed to) reflect any modifications subsequent to construction.

Henry

[Edwardd Lee]

Thanks Henry!