I was looking up the difference between the two classes and this point came up in a lot of the answers with this blog being the source: http://javarevisited.blogspot.com/2010/10/difference-between-hashmap-and.html
However I don't completely get it. Can someone elaborate this? Perhaps with an example?
Thanks for looking in!
Fail-fast iterators checks the modCount flag whenever it gets the next value (i.e. using next() method), and if it finds that the modCount has been modified after this iterator has been created, it throws ConcurrentModificationException.
Fail-Fast systems abort operation as-fast-as-possible exposing failures immediately and stopping the whole operation. Whereas, Fail-Safe systems don't abort an operation in the case of a failure. Such systems try to avoid raising failures as much as possible.
That aside, essentially, "fail-fast" in this sense means that an Iterator over a HashMap will throw an exception if it detects that another thread has modified the targeted HashMap - if you look in the source for HashMap, you will see this is done by simply checking a counter for the number of expected modifications.
Fail fast is a philosophy that values extensive testing and incremental development to determine whether an idea has value. An important goal of the philosophy is to cut losses when testing reveals something isn't working and quickly try something else, a concept known as pivoting.
The best way is to probably look at the source for each class as implemented by the Open JDK implementation for each class; that way, you can get your answer straight from the horse's mouth, as it were :-)
That aside, essentially, "fail-fast" in this sense means that an Iterator over a HashMap will throw an exception if it detects that another thread has modified the targeted HashMap - if you look in the source for HashMap, you will see this is done by simply checking a counter for the number of expected modifications. If the modification count is different than the Iterator expected, that means that someone else has come in since the last check and messed around with the HashMap, and so the Iterator throws a ConcurrentModificationException.
A "non fail-fast" Iterator wouldn't bother to check, and happily go along it's business in the underlying data structure. Therefore, you gain some flexibility (probably dubious flexibility in this case) in exchange for possibly running into errors later; i.e. attempting to access a value that is no longer present.
As with all fail-fast strategies, the idea is that the earlier an error is detected, the easier it is to recover from or debug.
Fail-fast means when you try to modify the content when you are iterating thru it, it will fail and throw ConcurrentModificationException.
Set keys = hashMap.keySet();
for (Object key : keys) {
hashMap.put(someObject, someValue); //it will throw the ConcurrentModificationException here
}
For HashTable enumeration:
Enumeration keys = hashTable.keys();
while (keys.hasMoreElements()) {
hashTable.put(someKey, someValue); //this is ok
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With