Inside Java: Concurrent modification when using collection and iterator

ConcurrentModificationException may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible. This exception is encountered more often in case of collections when one thread is iterating over the collection and other tries to modify it.

This article explains how java detects concurrent modifications to a List with the help of an example. The comments provided along with the code are self explanatory so let us go through the example first:

package com.technicalmusings.examples.collection;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

* The class explains how concurrent modification is detected in List.

public class ConcurrentModificationTest {

public static void main(String[] args) {

// Instantiating the list sets the modCount field of list to 0
// modCount is a protected integer variable defined in the AbstractList class.

List<Object> myList = new LinkedList<Object>();

myList.add(new Object()); // modCount incremented to 1
myList.add(new Object()); // modCount incremented to 2
myList.add(new Object()); // modCount incremented to 3

// Getting an iterator sets the value of expectedModCount field
// equal to that of the modCount field of list.

Iterator<Object> itr1 = myList.iterator(); //itr1: expectedModCount = 3
Iterator<Object> itr2 = myList.iterator(); //itr2: expectedModCount = 3

// The first Iterator traverses the list once;

// The second iterator traverses and removes the first element;
// In the previous step Itr2 modifies the list and sets the
// expectedModCount field to 4. The modCount field of the list
// has also been now incremented to 4

// The first iterator again tries to traverse the list;

// java.util.ConcurrentModificationException is thrown at this stage
// because itr1 finds its expectedModCount (which is still 3) to be not
// matching with the modCount field of the list

The class shown above explains how java works behind the scenes to detect concurrent modification and throw the ConcurrentModificationException in case of a List. List has an integer field modCount, which is incremented each time a structural modification is done in the list. Structural modification includes methods like add, remove, clear etc. The Iterator on the other hand uses another integer field, expectedModCount, to take care of concurrent modifications in the list. Iterator expects both the variables modCount and expectedModCount to be the same. In case the list is modified by any other means the modCount and expectedModCount differs and the exception is thrown.

Java Threads: Thread and Exception Handling

Whenever an uncaught exception occurs in a thread’s run method we get a default exception dump which gets printed on System.err stream. We may not always want to live with this default behavior and might think about logging the exception message in a more sophisticated way or doing something else as per business requirement.

Such custom exception handling can be achieved using the UncaughtExceptionHandler interface of the Thread class. The ThreadGroup class also implements the Thread.UncaughtExceptionHandler interface. The interface has only one method defined, which is:

void uncaughtException(Thread t, Throwable e);

This handler interface is invoked when a thread abruptly terminates due to an uncaught exception. The below excerpt from Java documentation explains the UncaughtExceptionHandler interface:

When a thread is about to terminate due to an uncaught exception the Java Virtual Machine will query the thread for its UncaughtExceptionHandler using Thread.getUncaughtExceptionHandler() and will invoke the handler’s uncaughtException method, passing the thread and the exception as arguments. If a thread has not had its UncaughtExceptionHandler explicitly set, then its ThreadGroup object acts as its UncaughtExceptionHandler. If the ThreadGroup object has no special requirements for dealing with the exception, it can forward the invocation to the default uncaught exception handler.

Thread class has two methods viz. setDefaultUncaughtExceptionHandler() and setUncaughtExceptionHandler(). The setDefaultUncaughtExceptionHandler() which is a static method of Thread class can be used to provide a common exception handler for all the threads. On the other hand setUncaughtExceptionHandler() is a non static method of Thread class which is used to provide handler to a given thread.

The below example shows how to handle the uncaught exception thrown from a Thread:

package com.technicalmusings.examples.thread;

* The below class creates a thread which is supposed to throw an exception.

* A handler is added to the thread before calling the start method of thread.
* When the thread executes the exception is handled by the handler
* and the custom exception message is displayed on the console.

public class MyThreadTest {

public static void main(String[] args) {

Thread newThread = new Thread(new ThreadWithException());

// Add the handler to the thread object
newThread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler(){

public void uncaughtException(Thread t, Throwable e) {

System.out.println("ERROR! An exception occurred in " + t.getName() + ". Cause: " + e.getMessage());


* This thread throws a custom exception in its run method.

class ThreadWithException implements Runnable {

public void run() {
throw new RuntimeException("Application Specific Exception!!");


ERROR! An exception occurred in Thread-0. Cause: Application Specific Exception!!

Enjoy Learning,

We’ve always done it that way

We’ve always done it that way.

How many times you have heard this punch line and how many times implemented the same in your work or life? Sounds like a Déjà vu, isn’t it?

In the book Code Complete 2, Steve McConnell has referred to a very nice story to emphasis that we should not always adhere to the above line. The story goes as below:

Beth wanted to cook a pot roast according to an award-winning pot roast recipe handed down in her husband’s family. Her husband, Abdul, said that his mother had taught him to sprinkle it with salt and pepper, cut both ends off, put it in the pan, cover it, and cook it. Beth asked, “Why do you cut both ends off?” Abdul said, “I don’t know. I’ve always done it that way. Let me ask my mother.” He called her, and she said, “I don’t know. I’ve always done it that way. Let me ask your grandmother.” She called his grandmother, who said, “I don’t know why you do it that way. I did it that way because it was too big to fit in my pan.



Scripting API in Java: Invoking JavaScript from Java

Scripting languages like JavaScript sometimes prove to be more flexible over the normal Java code. The Scripting API (javax.script.*) introduced in Java 6 allows to use the advantage of JavaScript in Java.

With the help of a Scripting Engine, the Scripting API can invoke scripts in the Java code. Java 6 comes with an implementation of JavaScript interpreter by Mozilla, Rhino. Scripting engines for other scripting languages can be found at

Let us see an example of how to invoke JavaScript from a Java class.

package com.technicalmusings.sample.js;
import java.util.List;
import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineFactory;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class ScriptRunner {

public static void main(String[] args) throws Exception{

    //the script manager
    ScriptEngineManager scriptManager = new ScriptEngineManager();

    //Check the available script engines
    List<ScriptEngineFactory> scriptFactories = scriptManager.getEngineFactories();

    System.out.println("Available Engines in Java 1.6.0_17:");
    for (ScriptEngineFactory factory : scriptFactories){

    System.out.println("Java Script Variables");

    //Get the java script engine
    ScriptEngine engine = scriptManager.getEngineByName("JavaScript");

    * Variables evaluated in JavaScript engine defaults to engine scope.
    * In the below example I am using the method engine.eval(String
    * script) to invoke JavaScript. In case you wish to store JavaScript
    * in a file like abc.js, you can use the overloaded version of the
    * same method which takes a Reader object; engine.eval(Reader
    * reader);

    engine.put("i", 10);
    System.out.println("i * 10 : " + engine.eval("i * 10"));//100
    System.out.println("i : " + engine.eval("i"));//10
    System.out.println("i = i * 10 : " + engine.eval("i = i * 10"));//100
    System.out.println("i : " + engine.eval("i"));//100

    //using javascript variable in java
    int i = ((Double)engine.eval("i")).intValue();
    System.out.println("JavaScript variable in Java; i : " + i);

    * Script engines provide the feature of invoking a function. In order
    * to be able to invoke a function the script engine must implement
    * the Invocable interface. Following example shows how to use a
    * simple function in JavaScript.

    System.out.println("Java Script Function");
    //Check whether engine implements Invocable as it depends on the engine’s implementation.
    if(engine instanceof Invocable){
    //Declare the function
        String functionScript = "function display(message){ return message }";

        //Invoke the function with a String parameter
        String message = "Hey JS! Greetings from Java";
        Object result = ((Invocable)engine).invokeFunction("display", message);

        //Invoke the function using a pre defined variable
        result = ((Invocable)engine).invokeFunction("display", "i is " + engine.eval("i"));

The output of the above example is given as below:

Available Engines in Java 1.6.0_17:
Mozilla Rhino
Java Script Variables

i * 10 : 100.0
i : 10
i = i * 10 : 100.0
i : 100.0
Java Script Function
Hey JS! Greetings from Java
i is 100.0

I have shown very basic use of the scripting APIs in this post. There are many other features which a scripting engine provides. For example if we require executing a script multiple times we can compile the script once and use that as required. The engine in that case must implement the Compilable interface.

The Scripting API also solved the problem of using a JavaScript variable in java and vice-versa. Most of the times we face this problem in a JSP where we have to use workarounds. Though I still need to test this but this should work. Let me know if you have tested the same.

Enjoy Learning,


Java Interview: Checklist

I am listing below the checklist of concepts and keywords in java which are most frequently asked in interview. Please excuse me for presenting it in a random order.

Following are the topics/keywords/concepts which require a crisp knowledge and understanding. These are basisc only.

  • JVM – About JVM, JIT compiler, Bytecode, Classloader
  • Garbage Colection – Conditions when JVM invokes garbage collection, System.gc()
  • Static and Instance initializer block
  • Datatypes – character especially
  • enum – where to declare, defining constructor, methods and variables in enum
  • OOP concepts – inheritance, polymorphism, aggregation vs Composition, abstraction
  • Multiple Inheritance in java
  • Difference/Similarities between interface and abstract class
  • Software Engineering Concepts – Coupling and Cohesion
  • String, StringBuffer and StringBuilder
  • Exception Handling – Checked vs Unchecked Exceptions, Assertion, Error, Exception Hierarchy, throw vs throws
  • final, finally and finalize
  • Method Overriding (Rules for the same)
  • Method Overloading – Covariant Return (Java5)
  • Autoboxing
  • Array – Declaring an anonymous and multidimensional array
  • Keywords like super and this
  • The Object classs – equals and hashcode methods
  • Access Specifiers – default, public , protected and private
  • Marker Interface, Wrapper Classe and Adapter Class
  • Classes like Math, StrictMath, Scanner, Console
  • Java IO: Important classes in IO, NIO.
  • Reading and writing XMLs in java. Type of parsers – SAX, DOM and STAX.
  • Java UI: AWT vs Swing, Different Layouts, Event handling, Calback methods
  • Serialization, Transient keyword
  • Multithreading – Runnable vs Thread, How to write a thread, difference between run and start method.
  • Java5 Concurrency and advanced threading – Callable, Future, Executors, Thread pooling, Locks and Conditions
  • Collection and Generics – Map, Set and List; Conventional Questions like ArrayList vs Vector, HashTable vs HashMap etc; Comparator and Comparable; Important collection classes.
  • Methods of java.util.Collections – Synchronizing a collection, Creating views
  • JDBC: The JDBC code, Type of JDBC Drivers, Type of Statements, execute, executeUpdate and executeQuery

We can discuss these further in case of queries/suggestions. Feel free to comment and add in case I missed something.

Enjoy learning,


Java Facts: Multiple Inheritance

“Does Java Support Multiple Inheritance?” This is one of the most favorite java interview questions.

Whenever this question is asked the most common (and sometimes expected) answers are:

“No” or

“Well! Java does support multiple inheritance but with the interfaces not the classes.”

Both the answers are correct and accepted.

However we can find a better answer of the same question if we go by what the Java Specification has to say:

Classes support single implementation inheritance, in which the implementation

of each class is derived from that of a single superclass, and ultimately from

the class Object.”

“Multiple interface inheritance is supported.”

The term ‘implementation inheritance’ may be confused with the keyword implements, which is incorrect. Implementation inheritance means a class can inherit (using the keyword extends) only one super class.e.g.

Incorrect: public class Derived extends Base1, Base2

Correct:  public class Derived extends Base

On the other hand Interface Inheritance implies that a class can implement multiple interfaces (using implements keyword) and an interface can extend multiple interfaces (using extends keyword).

Correct: public class Concrete implements A, B

Correct: public interface C extends A, B

Incorrect: public interface C implements A, B

The concept of inheritance differs from that of C++ in order to avoid the classic diamond problem in C++.

Enjoy Learning,

Inside Java: Arrays.asList(T… a)

We frequently use asList method of Arrays class to convert an array to a list. In order to use this method properly we need to know what is happening behind the scene. The complete signature of this method is:   

      public static <T> List<T> asList(T... a)

This method is declared and defined in java.util.Arrays class. The method returns an object of ArrayList class. But here is one difference which we have to note and take care while using this.     

The object being returned does not belong to java.util.ArrayList class rather it belongs to java.util.Arrays$ArrayList class. Surprised! Actually the Arrays class defines an private static inner class named ArrayList. Following is the signature of the ArrayList class:     

      private static class ArrayList<E> extends AbstractList<E>implements RandomAccess, 


Now let us see what the difference between the two ArrayList classes is.  

The Arrays$ArrayList class is sometimes refered as the view of java.util.ArrayList or a fixed size list. This class does not override all the methods of AbstractList class. To be more precise, following are the methods it overrides or declares:     

      public int size()  

      public Object[] toArray()

      public <T> T[] toArray(T[] a)

      public E get(int index)

      public E set(int index, E element)

      public int indexOf(Object o)

      public boolean contains(Object o)


Other methods if being called refer to the AbstractList class default implementation.  

For example if we try to call the add or remove method of Arrays$ArrayList class, we will get an UnsupportedOperationException . The reason behind this is the implementation of these methods in the AbstractList class which is:  

      public void add(int index, E element) {
                 throw new UnsupportedOperationException();

      public E remove(int  index) {
                 throw new  UnsupportedOperationException();


I hope this clears the understanding of how views are being used in java.

Let us conclude this article with the javadoc comments of Arrays.asList method: 

Returns a fixed-size list backed by the specified array.  (Changes to the returned list “write through” to the array.)  This method acts as bridge between array-based and collection-based APIs, in combination with Collection#toArray.  The returned list is serializable and implements RandomAccess.

This method also provides a convenient way to create a fixed-size list initialized to contain several elements:
List<String> stooges = Arrays.asList(“Larry”, “Moe”, “Curly”);

Enjoy Learning,