Overview of Java exceptions and threads

Java exceptions

Java exceptions are derived from a class called Throwable. It has two subclasses: Error, which deals with errors in the Java virtual machine (those errors are not related to the program code and are beyond a programmer's control) and Exception. The class Exception includes standard kinds of exceptions, s.a. ArithmeticException and ArrayIndexOutOfBounds. A programmer may define his/her own exceptions by extending the class Exception.

A block of code which is monitored for exceptions is included between the keywords try and catch. There may be several catch statements for each try, as long as they catch different kinds of exceptions:

try {
	for (int i = 0; i < 10; ++i) {
		System.out.println(numer[i] + " / " + denom[i] + " = " + numer[i]/denom[i]);
	}
} 
catch (ArithmeticException e) {
	System.out.println("Division by zero!");
}
catch (ArrayIndexOutOfBounds e) {
	System.out.println("Can't go out of the array boundaries!");
}

Instead of using your own message, as in the example above, you can also just pass the exception as a parameter to println, and a standard message for the exception will be printed. You can also invoke a method printStackTrace() on an exception to print out the sequence of method invocations that the exception occured within. To catch any possible exception, use catch (Throwable e).

You can declare your own exceptions by extending the class Exception. In order to display your own exception message, you need to override the default toString() method of an exception. You may use an exception to check for certain conditions in your program. For instance, you if a method requires that a parameter is a positive integer, you can throw an exception if it is not. Exceptions are objects, so in order to throw an exception, you need to create a new exception object first.
Click here for an example.

If a method throws an exception which it does not catch, and the exception is not of the class Error or RuntimeException, then the method declaration must specify the exception that it throws, for instance:

public void mymethod(...) throws Exception1, Exception2 {
	//body
}

What are Java threads

An important advantage of using threads is that they allow the program to utilize time which would otherwise be spent waiting for an I/O device or some other slower process.

Threads are also called light-weight processes (LWP). They provide convenience of multi-processing (i.e. creating multiple processes run separately by the operating system) without the overhead of setting up a new process. Communication between threads and sharing of resources is also easier than that between separate processes.

Java provides classes and methods that allow creating and manipulating threads. While these classes and methods are part of the Java standard, one has to keep in mind that the actual implementation of threads depends on the operating system, and therefore thread behaviour differs from one machine to another for the same version of Java.

Thread methods and life cycle

1. newly created
2. running on the CPU.
3. ready to run, waiting for CPU time.
4. suspended, temporarily stopped execution, possible to let a thread with a higher priority run. A suspended thread can later be resumed.
5. blocked, waiting for a resource or an event.
6. terminated, the execution has ended and cannot be resumed.

1. thread constructor. Some versions of the constructor are:
   • Thread()
   • Thread(String name)
   • Thread(Runnable r)
   • Thread(Runnable r, String name)
   Every thread has a name. If it's not passed to the constructor, then a default name is given. You can change it by using setName(String name) method. We discuss Runnable below.
2. void run().
   The method where the behaviour of the thread is defined. Is invoked when the thread starts running.run() can pass control to other methods, in which case if the thread is suspended, and then resume, it will continue from the point at which it has been suspended.
3. void start().
   Starts a newly created thread by invoking its run() method. If the thread can get CPU time, it becomes running, otherwise it becomes ready to run.
4. static void sleep(long milliseconds) throws InterruptedException
   Suspends the thread for the specified time. The thread goes from running to suspended. The method is static, i.e. it should be invoked on the class, as follows: Thread.sleep(100). It suspends the thread in which it is invoked. Because it throws an exception which is not in RuntimeException, it has to be inside a try/catch block.
5. final void join() throws InterruptedException
   The method waits until the thread on which it's called terminates. The waiting thread becomes blocked. For instance, by putting thr.join() in the end of main we guarantee that main is not going to terminate until thr does.
6. static void yield().
   Causes the currently running thread to pause temporarily to let the other threads run. The thread becomes runnable, but not running.

Two ways of implementing threads in Java

• Extending the class Thread. The subclass should override the default method run() with the code that specifies behaviour of the threads. Since threads are objects, a new instance of the class is created by the new keyword. To start the tread, we invoke method start() on each instance.
  Click here for an example.
• Declaring a class that implements Runnable interface. The class implements the run() method. To create a new thread this way, one has to create an instance of the class, and then create a new thread, passing the instance of Runnable to the thread constructor as an argument.
  Click here for an example.
  Since each Java class can inherit from only one class, a class which extends Thread cannot extend any other class. If a class implements Runnable inteface, it can also extend another class, which gives more options to a programmer.

Access control using the synchronized keyword

     public class Account {
             String holderName;
             float amount;
             public Account(String name, float amt) {
                     holderName = name;
                     amount = amt;
             }
             public void deposit(float amt) {
                     amount += amt;
             }
             public void withdraw(float amt) {
                 if (amt < amount) 
                      amount -= amt;
             }
             public float checkBalance() {
                     return amount;
             }
     }

We can prevent this scenario by "locking" the account so that only one thread at a time can perform deposits or withdrawals. Each object in Java has a monitor associated with it, and this monitor can be locked by invoking a method declared as "syncronized". If the object is locked, then no syncronized methods can access this object until the method that has locked the object terminates, thus releasing the lock. In the following code if one thread performs a deposit or a withdrawal from the account, no other thread can perform deposits or withdrawals. However, checkBalance() can be performed at any time, since it does not need lock for an the account.

     public class Account {
             String holderName;
             float amount;
             public Account(String name, float amt) {
                     holderName = name;
                     amount = amt;
             }
             public syncronized void deposit(float amt) {
                     amount += amt;
             }
             public syncronized void withdraw(float amt) {
                      if (amt < amount) 
                             amount -= amt;
             }
             public float checkBalance() {
                     return amount;
             }
     }

Now threads that want to access the account are syncronized on this account, i.e. the account's monitor locks the account when a thread invokes its withdraw or deposit method.

It is also possible to prevent simultaneous access to a block of code as follows:

        syncronized(object) {
              // statements to be syncronized
				}

When a thread is waiting to execute a syncronized method on an object that's currently locked, the thread is blocked

Threads communication using wait() and notify()

The following three methods of class Object allow threads to communicate so that they can coordinate their access to the buffer:

• wait() Suspends the current thread until a notify() is invoked in a method of this object.
• notify() Notifies a thread waiting on the object, so that it can resume. Only one thread receives notification. If there are several threads waiting, it depends on the system to decide which one will get the notification.
• notifyAll()Notify all threads waiting on the object.

Here is a solution of the consumer/producer problem which uses wait() and notify().

Thread priority

Deadlocks and infinite postponement

Another problem that one might encounter in multithreaded programming is infinite postponement: a thread never gets to run because other threads with higher priority always get to run first. Again, care must be taken to avoid this problem.