If you are a newbie to working with java threads, this post will help you. Certifications like the SCJP require you to understand java threads to a fair degree. Threads behavior can be difficult to understand even for experienced programmers, so I will try to present some examples which will help candidates identify how threads wait / lock and synchronize.

Lets cut the chit chat and jump into a problem. A program increments a counter in a for loop as shown below.

Synchronizing:

public class StaticSync
{
    public static final Object s_lock = new Object();
    public static int s_counter=0;
    public static void main(String... args)
    {
        new StaticSync().go();
    }
 
    public void go()
    {
        for(int iCounter=0; iCounter<50; iCounter++)
        {
            Thread thread = new Thread(new Incrementer(new StaticSync()));
            thread.start();
        }
    }
}
 
class Incrementer implements Runnable
{
    StaticSync m_staticSync=null;
    public Incrementer(StaticSync staticSync_INP)
    {
        m_staticSync = staticSync_INP;
    }
 
    public void run()
    {
        synchronized (m_staticSync.s_lock)
        {
            m_staticSync.s_counter++;
            System.out.println(m_staticSync.s_counter);
        }
    }
}

This program is pretty simple. This is the sort of code that you can expect on the SCJP exam. Advanced versions of the code above can also appear by adding notify() wait() sleep() etc into the picture. Let us concentrate on the program for now. What can be guaranteed about the output of this program ?

Can we say that Numbers 1 through 50 will be printed for sure ? What can be said about the order in which they are printed. Is there a guarantee about that ?

This program prints numbers 1 through 50 and does it consistently. What that means is that we can guarantee that this program will print 1->50 in ascending order. Why ?

Instances of a thread object lock on the same static object:

One thread manages to obtain a lock. The others wait:

We are creating a new Incrementer instance while starting each thread. We are also passing it a new StaticSync instance for every thread. However when the code tries to update the counter, it synchronizes over a static object. The static object has only one instance, so when one of the 50 thread instances holds this lock, the other thread will have to wait until the lock is released.

Once the lock is released the next thread will update the counter variable. Since only one thread can obtain the lock at any given time, the operation of incrementing the counter and printing its value is atomic. What that means is that the ++ operation and the System.out.println() operation will happen without any other thread intefering in the middle. It happens as one single unit. Note that m_staticSync.s_lock is actually referring to the public static variable through a non static reference. This is not a recommended practice but it was used anyway to help readers understand the concept. The code also throws encapsulation out the window. Our focus is on the thread behavior of the code alone.

Now let us replace synchronized (m_staticSync.s_lock) with synchronized (this). What do you think will change (if there is any) and why ? What does “this” refer to here and how is the locking different from the locking we did in the first example ? If the program is modified so that we synchronize over a static method, which Object’s lock do we obtain ?

I will leave these questions to you as an exercise. The images below should provide a hint.

Threads locking on distinct object instances:

Everyone is a winner:

Moving on to thread interruptions

Interrupting:

public class ThreadInterrupt
{
 
    public static void main(String... args) throws Exception
    {
        new ThreadInterrupt().go();
    }
 
    public void go() throws Exception
    {
        InterruptTest interruptTest = new InterruptTest();
        Thread thread = new Thread(interruptTest);
        thread.start();
        Thread.sleep(1000);
        thread.interrupt();
        Thread.sleep(1000);
    }
 
}
 
class InterruptTest implements Runnable
{
    public void run()
    {
        try
        {
            synchronized (this)
            {
                System.out.println("Waiting");
                wait(30000);
            }
        }
        catch (InterruptedException e)
        {
            System.out.println("Inerrupted");
        }
    }
}

This class shows you how interruption of threads work. When a thread waits or sleeps, it goes into a blocking state. Such threads can be interrupted to come out of the blocking state. When such a thread gets “interrupted” from its blocking state, it throws an InterrutpedException. The output of the program above is

Waiting
Inerrupted

I have never used the interrupt() method at work. But it is useful to know that this can be done. Just remember that only threads that are blocking can be interrupted. Trying to interrupt threads in the running state will not work.

Notification:

public class NotificationExample
{
    public static Object lock = new Object();
    public static void main(String... args)
    {
        new NotificationExample().go();
    }
 
    public void go()
    {
        for(int iCounter=0; iCounter<100 ; iCounter++)
        {
            Thread thread = new Thread(new ThreadWorker());
            thread.start();
        }
        try
        {
            Thread.sleep(2000);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        synchronized (lock)
        {
            lock.notifyAll();
        }
    }
}
 
class ThreadWorker implements Runnable
{
    public void run()
    {
        synchronized (NotificationExample.lock)
        {
            try
            {
                NotificationExample.lock.wait();
                System.out.println(Thread.currentThread().getName() + " finished waiting");
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }
}

The SCJP exam expects you to understand how waiting and notifications happen in Threads. In this example, several threads synchronize over the same lock and then wait. A few seconds later a notifyAll() call is made to notify all the threads that were waiting on this Object’s lock. As an exercise, try to change the notifyAll() call to notify(). Observe what change that does to the execution of this program.

Some of the code displayed above uses the sleep() method to better explain and understand Thread behaviour when you run the examples. However making a Thread sleep does not guarantee any given result. You need to keep that in mind. The scenarios may also play out differently when you remove the calls to sleep(). What would happen for example if the notify() method is called before the threads actually begin waiting ?

You can toy around with those three examples to get a better grasp on threads.

To get sensitive user input without echoing it to the console/terminal, the Java SDK has introduced the java.io.Console class. The Console class is quite unique in the way it handles its data. It uses the native encoding of the system instead of the using the JVM’s default encoding.

The Console class provides methods to access the console/terminal, if any is associated with the JVM.

Using the Console class:
So how do you use the Console class ? Its pretty simple really. First get a reference to the Console class from the System class

Console con = System.console();

It is not always possible to get a reference to the console. Some scenarios prevent the developer from gaining access to the console. This method may return null in these cases. For example a batch process running on a server will not expect user input and usually does have a console. Your code must be capable of handling such situations.

Consider that you have a program that requires the user to secretly type in his/her password.

Entering sensitive data through the console:

Console con = System.console();
String user = con.readLine("Username: ");
char[] password = con.readPassword("Password: ");

If you were to run this code using the eclipse IDE it would not work (At least in eclipse 3.2).
This is because eclipse does not handle this code properly as yet. Run this code from the command prompt for now. Here is the output of the program

Output:

java com.Tests.Cert
Username: hello
Password:

Even though the output does not show a password being typed in, the user has typed it in on the console. The console’s feature allows the user to type in the password without it being echoed to the screen.

The line of code con.readLine(“Username: “); reads data from the console normally and stores it into a string. It also echoes whatever the user types onto the screen (you can see “hello” on the output). The line of code con.readPassword(“Password: “); prompts the user for a password but does not echo the contents of the password to the screen. This allows the user to enter his/her password safely using the Console class. To format the output to the screen the following code can be used.

Formatting data:

Console con = System.console();
String user = con.readLine("Welcome %s. Please login \nUsername:","Guest");
char[] password = con.readPassword("What is your password %s:",user);
System.out.println("User: " + user );
System.out.println("Password: " + new String (password) );

Output:

java com.Tests.Cert
Welcome Guest. Please login
Username: hello
What is your password hello:
User: hello
Password: bla

Notice that although the password is not visible in the console screen, the program was able to retrieve it. Also the line of code con.readPassword(“What is your password %s: “,user); will format the output such that the username is present when asking for the password. %s represents the String that was passed to the method. Now let’s take a look at using the format() method.

Formatting output only:

Console con = System.console();
con.format("Welcome %s \n", "Mr bond");
String user = con.readLine("Username: ");
char[] password = con.readPassword("What is your password %s:",user);
System.out.println("User: " + user );
System.out.println("Password: " + new String (password) );

Output:

Welcome Mr bond
Username: 007
What is your password 007:
User: 007
Password: goldeneye

In this case the formatting that was present in the readLine() method has been transferred to the format() method. Console also has a printf() method that works similar to the format() method. This method however has been made available only for convenience. Finally you can make use of the reader and writer classes to read and write to the Console.

Reader and Writer:
Note: This code throws IOException since we need read/write access to the console

char buffer[]= new char[1024];
Console con = System.console();
Reader reader = con.reader();
int numRead = reader.read(buffer); // #1
System.out.println(new String (buffer).substring(0, numRead) );
Writer writer = con.writer(); // #2
writer.write(buffer);
writer.flush();
writer.close();

Output:

reader -- #a. Input provided by a user
reader -- #b. Written by System.out
reader -- #c. Written by console writer

The #a reader is the input that was provided to the program. The program reads this data using the Reader class. It reads the data into a character buffer in line #1 and prints the data to the console . At line #2 the console’s writer is obtained by the program and the contents of the character buffer are sent to the console output again (this time using System.out). Be wary however, when you use the Reader and Writer classes. They throw the IOException and since this is a checked Exception it must be handled. The code above throws this exception from a method (not shown) and thus need not handle it.

Back to home

Before you can go ahead and take the real Sun Java exams, you need to know some of the pitfalls that have plagued several test takers. Here are a few pointer

Do not buy a voucher before you are prepared to take the exam:

Often some candidates like to follow this approach hoping that the purchase of the voucher would force them to learn within a given time period. On the contrary this adds additional pressure to your preparation, since you need to study the objectives before the expiry date. Some candidates have lost money misinterpreting the expiry date on the voucher. Be wary of the MM/DD/YYYY Vs DD/MM/YYYY formats. Which one does your voucher display ?

When the candidates finally find that they have no more time to learn, they post a message on a forum that reads something like ‘I have voucher for exam X for a discount of Y%. Please call me to buy’. Remember, you are a candidate, not a voucher reseller

Material made available to you inside the exam room:

Prometric centers will not provide you with pen/paper/pencil at the time of the exam. You will be given a plastic sheet and a marker/felt pen. You can jot down on the plastic sheet with the pen.

Mobile phones, PDAs, and other object that would allow a candidate to cheat are not allowed. Also make sure that once you are ready, you book your exam slot in advance. This ensures that you dont spend anxious minutes waiting to buy one just before the exam.

Beware of drag and drops:

All Sun Java certification real exams run on a managed software. This software has a user interface where some questions require that you drag elements and drop them into their appropriate places. Beware though, once you answer a drag and drop question you cannot review its answer again. Which means if you do answer the Drag and drop question, when you try to review the answer next time the answer will be lost / reset. If you want to, you can jot down the drag and drop answer on the plastic sheet given to you and review it later.

Code analysis:

It is important to analyze the code presented to you even before you attempt to find the solution. Scan the entire class for well known problems before continuing your analysis

• Are non-static variables referred from a static context ?
• Are there infinite loops ?
• Is there a compile time error ?
• Are method overridden correctly ?
• etc etc…

Once you know how to scan for such patterns, answering the question will become easier.

Am I ready ?:

So when do you that you are ready to take the exam ? Thats a tough one to answer. There are candidates that get 50% on the mock exam but pass the real exam with flying colors. Then there are the ones that pass mock exams and fail the real one. The latter group is rare. At the end of the day if you know what your weak points are and you are confident that you can strengthen them, go for it !.

Back to home

Sets:

A Set is a collection that contains no duplicate elements. Sets are collections where no two elements are the same, which means that element1.equals(element2) should never return true. Also at most one element in a set can be null and no more.

A Set. Duplicates are not allowed and at most one null element is allowed

Sorted Sets:

A SortedSet is a set which sorts and maintains the ordering of its elements. Elements will be ordered by their natural ordering or by the use of a Comparator (if the developer provides one). A Comparable interface can help define the ordering for elements. For example a String’s natural ordering will dictate that elements be ordered this way “a”, “b”, “c” etc. The way in which elements are ordered in a Sorted data structure can be redefined by using the Comparator interface.

Sorted set where elements are sorted by natural order.

Navigable set:

A navigable set is a sorted set. Technically this means that a NavigableSet extends from a SortedSet. The navigable set has a couple of methods that will return the closest matching element given a search target. A NavigableSet can be accessed in the ascending or descending order. To get an ascending view of this structure the iterator() method can be used like in all Collection classes. To get a descending view of this structure use the descendingIterator() method. This method returns an Iterator whose elements are in the reverse natural order. That.s a fancy way of saying .in descending order.

The implementations of NavigableSet are the TreeSet and the ConcurrentSkipListSet. Let us take an example of the Iteration orders of the navigable set

Code:

public static void main(String[] args) 
{
    NavigableSet <Integer> navigableSet  = new TreeSet<Integer>();
    navigableSet.add(10);
    navigableSet.add(20);
    navigableSet.add(-10);
    navigableSet.add(40);
    navigableSet.add(90);
    Iterator< Integer> iterator = navigableSet.iterator();
    Iterator< Integer> reverseIterator = navigableSet.descendingIterator();
    System.out.println("Forward ahoy !");
    while (iterator.hasNext())
    {
        System.out.println(iterator.next());
    }
    System.out.println();
    System.out.println("Reverse yoha !");
    while (reverseIterator.hasNext())
    {
        System.out.println(reverseIterator.next());
    }
}

Output:

The output of this program would be:
Forward ahoy !
-10
10
20
40
90
 
Reverse yoha !
90
40
20
10
-10

As expected the Iterators iterate through the set in the natural and reverse natural order. Tree sets also automatically sort their elements. There are some key methods that make the NavigableSet useful in certain scenarios. We will have a look at them now.

Key methods in the NavigableSet:

Don’t worry if some of these methods do not make sense. We will take a look at them with an example

A small program illustrates each method. Assume that a NavigableSet is inserted with the following data just like before.

Values added into the set in this order:

Let’s say the following lines were executed in the program

System.out.println(navigableSet.floor(5));
System.out.println(navigableSet.ceiling(5));
System.out.println(navigableSet.lower(30));
System.out.println(navigableSet.higher(30));
System.out.println(navigableSet.higher(90));

The output would be as follows:

-10
10
20
40
Null

To explain the output, let’s arrange the elements first, the way a sorted set would see them

When the Set encounters methods like floor(),ceiling() etc, this is what it translates to.

floor(5) – Give me the element that is less than or equal to 5. Result is -10

ceiling(5) - Give me the element that is greater than or equal to 5. Result is 10

lower(30) - Give me the element that is less than 30. Result is 20

higher(30) - Give me the element that is greater than 30. Result is 40

Any request for an element that does not match the criteria will result in a null return. For example a request to the set to return something higher than 90 gives null since 90 is the highest value in the set.

More examples:

System.out.println(navigableSet.subSet(10,true,40,true));
System.out.println(navigableSet.tailSet(-10, false));
System.out.println(navigableSet.headSet(40, true));
System.out.println(navigableSet.descendingSet());

The output:

[10, 20, 40]
[10, 20, 40, 90]
[-10, 10, 20, 40]
[90, 40, 20, 10, -10]

Again, given the sorted set this result can be explained.

subSet(10,true,40,true)- Give me all the elements between 10 and 40, inclusive of 10 and 40.

tailSet(-10, false) - Give me all the elements after -10, exclusive of -10.

headSet(40, true)- Give me all the elements before 40, inclusive of 40.

descendingSet()- Show me the Navigable set in descending order

The descending set is nothing but the set in reverse order. It is helpful if you need the entire set in descending order instead of a descending Iterator to the set. That laves us with pollFirst() and pollLast().

Polling through navigable sets:

System.out.println(navigableSet);
System.out.println(navigableSet.pollFirst());
System.out.println(navigableSet.pollLast());
System.out.println(navigableSet);

Output:

[-10, 10, 20, 40, 90]
-10
90
[10, 20, 40]

The pollFirst() method retrieves and removes the first value in the set. Which is -10. The pollLast() method retrieves and removes the last value in the set, which is 90. As a result the set.s final size is reduced by 2. After removal of -10 and 90 from the set, the final set looks like this [10, 20, 40].

The NavigableMap API is very similar to that of the NavigableSet (It is unfair to compare a Map and Set, but you get the picture). Now that you know how to use a NavigableSet, learning the NavigableMap should easy.

Back to home