Java Web Exam

For the job interview I had last week, I had do to live actual programming, (this is very rare and I know, I do a lot of interviews). They had a portable PC, loaded with Eclipse, Tomcat, Spring Source, and MySQL. The task in 90 minutes, given an existing (supposed hibernate based) MVC based and Java Standard Template Library using JSP, building a page displaying a summary of recent orders on each day, from the database.

Could you do that?

I failed the test myself. Got the Bean, the data access class (turned out not to be hibernate based after all), and Controller, all written, but eclipse drew red lines all over the Java code between the <% %> brackets in my code. There set up also had Stack Traces disabled, with a nice error page saying (Whoops its broken), instead of the useful info on what went wrong.

Java.util.Concurrent, Part 3 - Queues

In multi-threaded programming, its common to have both producers that create or
retrieve from something external, and also consumers that process what ever retrieved. Since there no knowing in general how quickly either process happen. In between we need a Queue of objects waiting to be processed. Java.util.Concurrent adds blocking queue. Queues are extensions to the collections API which means you can use the generics mechanism to state what type of object you put into them. Here are the basic methods common to any blocking queue. Where a non block queue was has methods that throw exception if the queue is too empty or too full, a block queue has methods that wait until the situation is resolved. Blocking queue operation may be considered atomic from the point of view of threads.

void	put(O)	Adds a element to the queue, or waits for space.
boolean	offer(O)	Adds a element to the queue, if there is space or returns false.
boolean	offer(O, long timeout, TimeUnit unit)	Adds a element to the queue, or wait so long for space then returns false.
Object	take()	Take an element from the head of the queue, or waits for one to be there
boolean	poll(long timeout, TimeUnit unit)	Adds a element to the queue, or waits the given time for space.

You can also measure fullness of the queue with remainCapacity() or copy all the element to another collection with drainTo().

Standard Queue backed by LinkedLists or Arrays are both available as our.



Backed by a linked list

ArrayBlockingQueue	Backed by any Array
LinkedListBlockingQueue
DelayQueue	each element .getDelay(), the take method take the element whose .getDelay() method has fallen further below zero, or wait until then
PriorityBlockingQueue	The priority, the first element to be returned is order by a Comparator (or Natural ordering, alphabetical for String etc)
SychronousQueue	Stores nothing, waits until both a take and a put thread are blocking at the same time.

Java.util.Concurrent, Part 2 - Conditions

In the Java 5 and newer API, Conditions are Object designed to replace the simple wait and notify tasks in the earlier API. You get a Condition object, by calling the NewCondition method on any lock, you can make as many Conditions as you like on one lock. You can make a thread wait on the Condition one of 5 ways.

void	await()	Until a Signal or Interrupted
boolean	await(long, TimeUnit unit)	For a set time, or a Signal or Interrupted, returns true if woken by Signal or Interrupt
long	awaitNanos()	Wait a time in Nanoseconds, return how much waiting time was left, if signalled
void	awaitUniterruptable()	Only a Signal will awake this method
boolean	awaitUntil(Date deadline)	Waits until deadline or signalled, return true if signalled

All these methods, release the lock the condition was make from, where waiting. One
of to method might be used to singal the waiting condition.

void	signal()	Signal to wake one waiting condition
void	signalAll()	Signal to wake all waiting conditions

In a queue example, we would want to wake up only one waiting thread. But if a major tasked finished, we might wan't to wake up a the waiting threads.

Java.util.Concurrent, Part 1 - Locks

You might have missed this glem in API, Released back in 2006 with Java 5.0, util.Concurrent is a Java API extention, giving all sorts of tricks and methodology for hightly multithreaded code. With chips becoming ever more multithreaded, perphaps
even 512 way by 2020. Your find yourself ever push to make more use of multiple threads. And the Concurrent API certainly make it easier. Lets have a look at some of the tricks in the new API.

Locks, in old fashioned java, when you had a critical set of code, a piece you want to be sure, only one thread was going to run at a time. You use to have to synchronize it on a object invented for the task. But in Java 5 and onwards have also proper locks in a variatly of types.

import java.util.concurrent.lock; Lock myLock = new ReentractLock(); try {    myLock.lock();    // Thread safe code } finally {    myLock.unlock; }

The API provide to general interfaces, Lock and ReadWriteLock, and three classes, RentrantLock, RentrantReadWriteLock.ReadLock, RentrantReadWriteLock.WriteLock. Rentrant means the calling class can try and gain the lock as many times as it like without problems, only once it was unlock as many lock as it has acquired will another thread beable to acquire the lock. The RentractReadWriteLock is usually for double end object such as queues, seperate class may be able to gain different locks. Allowing different threads to be reading and writing the queue at the same time.