ConcurrentHashMap上的元素轮循

Question

I am trying to implement a function that do a round robin on elements of a ConcurrentHashMap. For example, if there are {a, b, c} elements in the ConcurrentHashMap, the first time I call the function, it returns a, the second time, it returns b, the third time, it returns c, the forth time, it returns a.

private static Enumeration<Peer> nhEnmu;
private static final ConcurrentHashMap<String, Peer> peers;

private synchronized static Peer getNextPeer()
{
    if (nhEnmu == null || !nhEnmu.hasMoreElements())
    {
        nhEnmu = peers.elements();
    }

    return nhEnmu.nextElement();
}

I implemented this function as above, however, the NoSuchElementException keeps poping out, I am wondering that is there anything wrong for using the elements() method? If it is not appropriate, what implementation should I adapt? Thank you!

The exception trace is as follows:

at Main$MsgProcessorThread.run(Main.java:119)
Exception in thread "Thread-1" java.util.NoSuchElementException at
java.util.concurrent.ConcurrentHashMap$HashIterator.nextEntry(ConcurrentHashMap.java:1266) at
java.util.concurrent.ConcurrentHashMap$ValueIterator.nextElement(ConcurrentHashMap.java:1297) at 
control.Protocol.getNextPeer(Protocol.java:89)

Answer 1

According to this question iterators returned are not thread safe. If so, and you are accessing the iterator on multiple thread, this exception could occur.

You probably have a method to add and remove peers in this class too. Try keeping a list of peers and an index into that list. When you remove a peer, remove that peer from both the hashmap and your peer round robin list, and update your index appropriately. Do the same thing when adding.

Then when getNextPeer is called, return the next peer in your list and increment your index. Wrap back to zero if index exceeds the size of the list.

Something like....

private static List<Peer> nhEnmu;
private static int index;
private static final ConcurrentHashMap<String, Peer> peers;

private synchronized static Peer getNextPeer()
{
    Peer peer = null;
    if (nhEnmu.size()>0)
    {
        peer = nhEnmu.get(index);
        index++;
        if(index>=nhEnmu.size())
            index = 0;
    }
    return peer;
}

Answer 2

Use ConcurrentHashMap.entrySet() directly instead. it is safe.