Nothing Important

I guess volatile is the most ignored keyword among normal java folks, everyone knows there is a volatile keyword but no one know why. So I will explain the purpose for volatile keyword.

volatile keyword is to indicate java and other threads not to cache the local variable value but read/write it from main memory every time.

volatile keyword is to variables what synchronised is to code blocks. 

volatile keyword is to ensure atomicity of local variables in a multi threaded environment, where different threads do the reading and writing on same local variable. 

Atomicity

Let take the example of Double checking Singleton implementation from previous post.

If we do not make INSTANCE variable volatile then Thread which is creating instance of Singleton will not able to communicate with other threads that an instance has been created, until it comes out of the synchronised block, so if Thread A is creating Singleton instance and just after creation lost the CPU, all other thread will not be able to see value of INSTANCE as not null and they will believe its still null.

Reader threads are not doing any locking and until writer thread comes out of synchronized block, memory will not be synchronized and value of INSTANCE will not be updated in main memory. With Volatile keyword such updates will be visible by all reader threads.

volatile for long and double

One more instance where volatile is useful is when writing to long and double variables in multithreaded environment.long and double are 64bit and many platforms(32 bit) perform writing to these variables in 2 steps, and to attain atomicity to writing of these variables, we should make these variables volatile.

One more important aspect of volatile is it ensures ordering of the statement execution, 

Ordering

Java is taught as Jit and executes line by line as written by us, it is not completely true for modern compiles and runtimes, modern compilers and runtimes do a lot of re-ordring of your code in order to optimise performance, and as any program these optimisers aren't perfects, and may lead to un desirable effects in highly multi threaded environments.

Volatile keyword here helps to inform java to not mess around with my code, and i need it as i write it.

Examples

We may not encounter many scenarios where we need to use volatile keyword unless we are into game programming or developing servers, few examples which i find interesting are.

Lets say i am writing a game related to fighting, and i maintain a shared boolean variable isDead, now when a player is dead one thread(yama) updates the variable to true and other threads will act as per it state, say the rendering engine starts making player to fall down, spill blood etc.

Singleton pattern is the most discussed, conflicted patten in java, due to threading and serialisation issues involved,

Now i will go through different ways to program Singleton in java. i will ignore private constructer part of theory.

Not so lazy init way

This is the simplest of all implementations until java 5+, 

Just have a private static final instance variable, instantiated inline. 

use getInstance to return it.

This is inherently thread safe as class loading is thread safe, no need to worry about java memory model, and it can be equivalent be lazy loading if there are no other public static methods in you singleton class other that getInstance.

For all intentions and purposes this is the second best singleton implementation.

public class A { private static final A singleton = new A(); private A() {} public static A getInstance() { return singleton; } }

True Lazy Init

This is implementation of singleton which is most complex and often drives away developers from this pattern, this has all issues of multi threading, serialisation, memory model. the best effort one can make is by using double checking and volatile.

Have a private instance variable but don't instantiate it inline.

Have a public static getInstanceMethod, whose primary function is to check if instance is created or else create it.

Now multiple issues kick in with implementation of getInstance method,

How to effectively make getInstance thread-safe.

How to handle serialisation, as java creates a new object on serialisation.

How to handle java memory model issues, where local memory space is not synched with the heap instantaniously. 

To address above issues we make our singleton class so complex that we use double checking, volatile instance, implement readresolve method to bypass new object creation on serialisation, make instance variables of singleton class transient.

public class DoubleCheckedLockingSingleton implements Serializable{ private volatile DoubleCheckedLockingSingleton INSTANCE; private transient String state; private DoubleCheckedLockingSingleton(){} public DoubleCheckedLockingSingleton getInstance(){ if(INSTANCE == null){ synchronized(DoubleCheckedLockingSingleton.class){ //double checking Singleton instance if(INSTANCE == null){ INSTANCE = new DoubleCheckedLockingSingleton(); } } } return INSTANCE; } private DoubleCheckedLockingSingleton readResolve() { return DoubleCheckedLockingSingleton.INSTANCE; } }

You can contemplate that above code is boilerplate, complex and time bomb. So this is the least preferred way of implementing singleton.

God sent Enums to Save Singleton

Now this an interesting,simple and best way to implement singleton, and the solution is, here it comes, use enum to hold singleton instead. But this is available only  from java 5+.

Thats it. thread-safety, memory model issues, serialisation all will taken care by it.

public enum Singleton { INSTANCE; private String state; public void printState() { System.out.println(state); } }

Now use it as Singleton.INSTANCE, thats all no private constructors, no getInstance etc.

1.12 Serialization of Enum Constants

Enum constants are serialized differently than ordinary serializable or externalizable objects. The serialized form of an enum constant consists solely of its name; field values of the constant are not present in the form. To serialize an enum constant, ObjectOutputStream writes the value returned by the enum constant's name method. To deserialize an enum constant,ObjectInputStream reads the constant name from the stream; the deserialized constant is then obtained by calling the java.lang.Enum.valueOf method, passing the constant's enum type along with the received constant name as arguments. Like other serializable or externalizable objects, enum constants can function as the targets of back references appearing subsequently in the serialization stream.

The process by which enum constants are serialized cannot be customized: any class-specificwriteObject, readObject, readObjectNoData, writeReplace, and readResolvemethods defined by enum types are ignored during serialization and deserialization. Similarly, anyserialPersistentFields or serialVersionUID field declarations are also ignored--all enum types have a fixed serialVersionUID of 0L. Documenting serializable fields and data for enum types is unnecessary, since there is no variation in the type of data sent.

This can be one of the many architectures which can be used to develop an end to end solution for web UI to show real time application log.

Think of deployment and build tools.

This solution joins two distinct modern technologies to solve one problem of real-time log viewing.

There are two parts to the problem,

Writing Log:

Use Capped Mongo DB collection to store logs, where each document will be a log line.(you can use multiple collections created on the fly per job, think jenkins).

Since it is capped there is no need to clean up of old log files, or worry about disk space, but be diligent while deciding the cap.

Let your application write the log statements to this mongo, you can use a log appender if you use log4j or jdk logging.

you can also make #3 hit and forget from application POV, with a thread pool to handle inserts.

Reading Log

      Main distinguishing feature of this architecture is in this part of it,

      Here we use Tailable Cursor feature of mongodb and tie it to Web sockets connections.

Write a UI which starts a Web Socket connection to your ws servlet passing Job ID when a job is clicked.

Your servlet should maintain a Job ID to List of Connections Connection.

On Open connection, insert Connection in the above Map, start a thread which starts reading tailable cursor for that job id.

Tailable cursor is like "tail -f" command in linux, where the cursor waits without closing when there is no more data in the collection until new data is inserted.

So when ever new log statement is inserted by the application we cursor we opened gets data.

Since we have list of connection per job id, we just write messages to the ws connection once we get data from tailable cursor.

     Few things to remember, 

When connection is closed, remove it from the List.

if List of connections is 0 for a given job, close the tailable cursor and end that thread and delete the job from map.

Above architecture solves the problem of developing a web application to view realtime log.

This solution can be improved on above base structure in different ways to scale it, depending on your requirements.

Like,

Pre fetch and cache current active job log before any ws connection is made.

use normal cursors for non active jobs.

shard data based on job id.

Below algorithm is to reverse a single linked list(No point reversing double linked list) using recursion.

Pure evil brute force....

There are multiple problems around linked lists which can be solved using multi-pointers.

All these problems fall in to category where you would need to determine size before finding "The' element, like 

Find the middle node(s) of a linked list.

Find  n-(x)th node of linked list.

The above can be solved in two pass traversal where you traverse through all elements to find size of linked list first, and then traverse to the required element using the size.

But always overreaching programming world requires more optimised solution, where you need to find the element in single traversal. 

Below algorithm explains how we can use multiple pointers to reach exact element while traversing only once,

The idea is simple as with every nice solution, below are steps for finding middle node of a linked list.

You maintain two pointers (references in java).

You increment one pointer on every iteration, normal linked traversal, i.e, node.next().

But maintain another pointer, which is incremented every second iteration.

By doing this by the time first pointer reaches end of linked list. your second pointer points to middle node.

You have to take care of normal edge conditions like even size list, etc.