Deadlock occurs when a group of processes blocks forever because each process is waiting for resources which are held by another process in the group. What happens is that a task is stuck waiting for another task to release a resource which itself is stuck waiting for another task to release a resource and so on such that a circular wait loop ensures. The result is that no task can proceed. Thus a deadlock results.

The classis case of deadlock is the Dining Philosopher problem.In this problem we have, say 5 philosophers sitting down for dinner at a round table.To the left and right of each philosopher is a chopstick and there are 5 of these chopsticks F1 – F5, illustrated below:

Dining philosopher problem

Reference: http://samplecodes.files.wordpress.com/2008/11/23.jpg

In order for each philospher to eat, they must pick up the left and right chopsticks.Each philosopher decides to pick up the chopstick on his right 1st before picking up the one on his left.After picking up the chopstick on the right, each philosopher attempts to pick up the chopstick on his left and if it is not yet available, has to wait.

Thus we can have the following scenario:

P1 picks up F1, waits to pick up F2P2 picks up F2, waits to pick up F3P3 picks up F3, waits to pick up F4P4 picks up F4, waits to pick up F1P5 picks up F5, waits to pick up F1

Thus we have a circular wait scenario, where each philosopher is waiting on the next philosopher to his left to drop his right chopstick and so on such that no philosopher can eat.

Here is Java code for a simpler example of deadlock involving 2 tasks:

Thus we see that i1 and i2 are 2 different Integer objects created in memory, hence i1==i2 produces false, but in the definition of the Integer wrapperthey are meaningfully equivalent (after all they both have value 2) hence i1.equals(i2) produces true.

Notice that both cases above invoke Thread.start() in order to start the new thread. In either case above, the result is a Thread object, where the run() method is the body of the thread. When the start() method of the Thread object is called, the interpreter creates a new thread to execute the run() method. The new thread continues to run until the run() method exits. Meanwhile the original thread continues running itself, starting with the statement following the start() method.

3. Using Executor interface

The Executor interface can be used to invoke threads as well. It isn’t really a new idiom, since either a Thread object or object that implements Runnable needs to be created first. The Executor interface provides a layer of indirection between a client and the execution of a task; instead of a client executing a task directly, an intermediate object executes the task. Executors allow you to manage the execution of asynchronous tasks without having to explicitly manage the lifecycle of threads.

Implement and create a new instance of Runnable.

Create a concrete instance of ExecutorService by calling one of the Executors factory methods.

This method is the simplest and most straightforward. It has the disadvantage, however that the subclass cannot override any other class than the Thread class. There is also tight coupling between the thread implementation and invocation.

Method 2 – Implementing the Runnable interfaceThis method is slightly more involved, it has the advantage that the Runnable subinterface can override another class, and there is a decoupling between the thread implementation and invocation.

Method 3 – Utilizing the Executor interfaceIn this method we pass an instance of the Thread class or a Runnable to the Executor interface.The advantage of this approach is that it provides a layer of indirection between a client and the execution of a task;instead of a client executing a task directly, an intermediate object executes the task. Executors allow you to manage the execution of asynchronous tasks without having to explicitly manage the lifecycle of threads.

What is the difference between an abstract data type (ADT) and a data structure ?

The question above can be reframed in a more concrete manner by asking this question:What is the difference between an array and a stack ?An array is a data structure while a stack is an abstract data type.An abstract data type (ADT) is a specification for how an ‘data’ interface should behave without any reference to its actual implementation.

The wikipedia definition of an ADT is as follows:An abstract data type is defined as a mathematical model of the data objects that make up a data type as well as the functions that operate on these objects.From the NIST Dictionary of Algorithms and Data structures we have the following definition of an ADT:A set of data values and associated operations that are precisely specified independent of any particular implementation.Thus in the case of a stack, it exhibits Last In First Out (LIFO) behavior when elements areadded to and removed from it. The concrete implementation of the ADT is where the data structure comes in. Thus a Stack can be implemented as an array or as a linked list.This might lead us to conclude that an ADT is more a “theoretical/abstract” concept, while the data structure has more to do with a concrete implementation.Under the definitions above,the following constructs are ADTs:

Stack

Queue

Bag

List

Priority Queue

Trie

Heap

Binary Tree

Set

Map

while these are data structures:

array

linked list

hash map/dictionary

We can gain a better understanding of this when we consider these constructs in Java.The ADT corresponds to the interface type, while the data structure would correspond to the concrete class.Thus a Java array, ArrayList, LinkedList, HashMap are actually data structures and the corresponding interfaces they implement would be equivalent to ADTs.See this article for more about abstract data types in Java

In order to figure out where a variable is stored in Java the most important factor is where the variable is declared. A general rule of thumb is this:

local variables are stored on the stack

instance variables are stored on the heap

static variables are stored on the PermGen area of the heap

There are caveats to this however, which are explained below:

Variable Storage Details

Local variables

Primitives and object references declared in a method will be stored on the stack. However, the actual object, if created using new() will be stored on the heap, regardless of where the declaration took place. Hence in the following piece of code: void aMethod() { int playerNum=5; Player pl=new Player(); }

The primitive variable playerNum and object reference variable pl will be stored on the stack, while the actual Player object itself will live on the heap. When the code exits aMethod and goes out of scope, playerNum and pl will be popped from the stack and cease to exist but the Player object will persist on the heap until it is eventually garbage collected.

Since an instance of Car can only be instantiated via a call to new(), we see that:

The Car object c lives on the heap

All instance primitives and objects that are part of the Car object are also stored on the heap.

Static variables

The rule for static variables is this: Static methods, primitive variables and object references are stored in the PermGen section of the heap since they are part of the reflection i.e. class, not instance related data. However, in the case of objects, the actual object itself is stored in the regular areas of the heap (young/old generation or survivor space).

The owner of the account would like to exercise all options that expire as close as possible before the date of May 18 as he will be out of town on that date. Come up with an SQL query that will show which options need to be exercised.The table name is optionsExpirationSchedule

In this article I explain what is meant by a clustered index and compare it with a non-clustered index.

Definition

A clustered index on a table determines the order in which the rows of the table are stored on disk. If the table has a clustered index, the rows of the table are stored in the same order as that of the clustered index. As an illustration, suppose we have a Customer table that contains the following columns:

customerID

firstName

lastName

where customerID is the primary key on the table. If we define the clustered index on customerID, then the rows of the table will be stored in sorted order according to customerID. This means that rows with customerID=1000, customerID=1001, etc will be adjacent to each other on disk.

Advantages and Disadvantages

The advantages of having a clustered index include the following:

Range queries involving the clustered index will be faster since once the row with 1st key value is located the remaining rows physically stored next to each other and no more searching is needed.

The leaf nodes of the B-tree that make up the clustered index contain the actual data pages as opposed to a non-clustered index where the leaf nodes contain pointers to rows on data pages. Hence there is 1 less level of indirection for a clustered index and this improves performance.

The disadvantages of a clustered index include:

Updates involving columns used in the clustered index result in a performance hit since the rows may have to be re-arranged to keep the table in sorted order in line with the clustered index. In light of this, it is recommended that a clustered index is created on a primary or foreign key, since this would be less prone to updates.

Comparison of clustered vs non-clustered indexes

Returning to our Customer table example, if we have a clustered index on Customer id, then the leaf node of the clustered index will contain the actual row data (data pages) for a particular customerID while for a non-clustered index the value of customerID and a pointer to the actual row is what is stored at the leaf node.

There can only be 1 clustered index per table, but multiple non-clustered indexes (up to 249 in the case of Sybase). This is because the rows in the table are physically ordered according to the clustered index and there is only 1 way of doing so.

A clustered index determines the order in which the rows of the table can be stored on disk, but this is not the case for a non-clustered index

A clustered index can be a performance hit in the case of updates to an indexed column since the rows may have to be re-ordered in order to maintain order. Range queries and queries involving indexed foreign keys tend to show better performance for a clustered vs non-clustered index.