Core Java

How to create immutable class?

May 8, 2017 By j2eereference Leave a Comment

What is an immutable class: A class whose object’s state cannot be changed or modified once created .Any modification made to immutable class object will produce new object. String is a good example of immutable class as any changes made to String Object will create new String Object.

How to make class immutable:

In order to create an immutable class, we need to follow below points

Final class: Declare the class final so that it cannot be inherited by any other class.
Private and final member variable: Declaring member variable as private ensures that fields will not be accessible outside the class and declaring them final will ensure that they cannot be change once assigned.
Setter Method: Never provide setter method only getter is allowed as setter method will change the state of object.
Objects of mutable class (mutable instance variable): If class contains mutable fields then return new object(copy of original object), not the reference variable to avoid change in object’s state. Example: HashMap or Date class object declared inside a class, as HashMap is a mutable class so any changes made to its object will not produce new object

Constructor: Initialize all field inside constructor and assign all mutable fields using new keyword.

Example to create Immutable class:

import java.util.HashMap;

final class MyImmutable
{
  private final Integer empId;
  private final String empName;
  private final HashMap<Integer,String> hmap;

  public MyImmutable(String ename,Integer empid,HashMap<Integer,String> hmap)
  {
    this.empName=ename;
    this.empId=empid;
    this.hmap=new HashMap<Integer,String>(hmap);
  }

 public Integer getEmpId() 
 {
   return empId;
 }

 public String getEmpName() 
 {
   return empName;
 }

 public HashMap<Integer,String> getMap() 
 {
   return (HashMap<Integer,String>) hmap.clone();
 }
}

import java.util.HashMap;

final class MyImmutable

{

private final Integer empId;

private final String empName;

private final HashMap<Integer,String> hmap;

public MyImmutable(String ename,Integer empid,HashMap<Integer,String> hmap)

{

this.empName=ename;

this.empId=empid;

this.hmap=new HashMap<Integer,String>(hmap);

}

public Integer getEmpId()

{

return empId;

}

public String getEmpName()

{

return empName;

}

public HashMap<Integer,String> getMap()

{

return (HashMap<Integer,String>) hmap.clone();

}

public class ImmutableDemo
{
  public static void main(String[] args) 
  {
    String empName=new String("Shobhna");
    Integer empId=new Integer(749022);
    String address="Sector 21 D,Faridabad";
    HashMap<Integer,String> hmap = new LinkedHashMap<Integer,String>();
    hmap.put(empId,address);
    MyImmutable myImmutable = new MyImmutable(empName, empId, hmap);
    System.out.println(myImmutable.getEmpName());
    System.out.println(myImmutable.getEmpId());
    System.out.println(myImmutable.getMap());
  }
}

public class ImmutableDemo

{

public static void main(String[] args)

{

String empName=new String("Shobhna");

Integer empId=new Integer(749022);

String address="Sector 21 D,Faridabad";

HashMap<Integer,String> hmap = new LinkedHashMap<Integer,String>();

hmap.put(empId,address);

MyImmutable myImmutable = new MyImmutable(empName, empId, hmap);

System.out.println(myImmutable.getEmpName());

System.out.println(myImmutable.getEmpId());

System.out.println(myImmutable.getMap());

}

Output:

Shobhna
749022
{749022=Sector 21 D,Faridabad}

In the above example ,we are creating immutable class and used all the steps described above to create immutable class. We also used HashMap Object (Mutable class)as an instance variable inside MyImmutable class , any changes made to this mutable object would not produce new HashMap object and make our class as mutable class and not an immutable class .So to make class immutable ,we need to return copy/clone of HashMap object and not reference variable of HashMap. Please refer example and check output .

Benefits of using Immutable class:

Immutable class is thread safe, so can be shared by multiple threads in concurrent environment.
As immutable class is thread safe so there is no need to use synchronization code and hence less code work for developer
Use of immutable object will increase application performance as there is no use of synchronized methods.
Immutable objects make good key in HashMap as we will get same key every time when we call hashcode() method.

Implementing Stack in java

May 5, 2017 By j2eereference Leave a Comment

What is Stack : A Stack is a data structure which follows LIFO pattern (Last In First Out) means last inserted element will be the first element to be removed from the stack. Here lets see how to do the stack implementation with array.

Stack operations:

push(element) : Push operation will add element at the top of stack.
pop() : Pop operation will remove element from the stack and return it.
peek() : Returns the element at the top of stack without removing.

Stack implementation using Array :

public class StackDemo 
 {
   private int stkSize;
   private int[] stkArr;
   private int top=-1;
  
   // constructor to create stack 
   public StackDemo(int size) 
   {
     this.stkSize = size;
     this.stkArr = new int[stkSize];
   }

   // push method  to add new element at the top of the stack 

   public void push(int element)
   {
     if(isFull())
     {
       System.out.println(("Stack is full. Please remove elements from the stack"));
     }
       System.out.println("Adding elements in the stack: "+element);
       this.stkArr[++top] = element;
     }

   // This method removes element from the top of the stack.

   public int pop() throws Exception 
   {
     if(this.isEmpty())
     {
       throw new Exception("Can not remove element as stack is empty.Please add elements in the stack.");
     }
     int entry = this.stkArr[top--];
     System.out.println("Removing elements at the top of stack: "+entry);
     return entry;
   }

   //This method returns element at the top of the stack without removing it.
   public int peek() 
   {
     return stkArr[top];
   }

   public boolean isEmpty() 
   {
     return (top == -1);
   }

 // This method will return true if the stack is full otherwise false

   public boolean isFull() 
   {
      return (top == stkSize - 1);
   }

    public static void main(String[] args) 
    {
       StackDemo stack = new StackDemo(20);
       for(int i=1;i<=15;i++)
       {
          stack.push(i);
       }
       for(int i=1;i<=10;i++)
       {
         try {
           stack.pop();
         } catch (Exception e) {
             e.printStackTrace();
        }
      }
      System.out.println("Element at the top of stack is : "+stack .peek());
   }
}

public class StackDemo

{

private int stkSize;

private int[] stkArr;

private int top=-1;

// constructor to create stack

public StackDemo(int size)

{

this.stkSize = size;

this.stkArr = new int[stkSize];

}

// push method to add new element at the top of the stack

public void push(int element)

{

if(isFull())

{

System.out.println(("Stack is full. Please remove elements from the stack"));

}

System.out.println("Adding elements in the stack: "+element);

this.stkArr[++top] = element;

}

// This method removes element from the top of the stack.

public int pop() throws Exception

{

if(this.isEmpty())

{

throw new Exception("Can not remove element as stack is empty.Please add elements in the stack.");

}

int entry = this.stkArr[top--];

System.out.println("Removing elements at the top of stack: "+entry);

return entry;

}

//This method returns element at the top of the stack without removing it.

public int peek()

{

return stkArr[top];

}

public boolean isEmpty()

{

return (top == -1);

}

// This method will return true if the stack is full otherwise false

public boolean isFull()

{

return (top == stkSize - 1);

}

public static void main(String[] args)

{

StackDemo stack = new StackDemo(20);

for(int i=1;i<=15;i++)

{

stack.push(i);

}

for(int i=1;i<=10;i++)

{

try {

stack.pop();

} catch (Exception e) {

e.printStackTrace();

}

System.out.println("Element at the top of stack is : "+stack .peek());

}

OutPut :
Adding elements in the stack: 1
Adding elements in the stack: 2
Adding elements in the stack: 3
Adding elements in the stack: 4
Adding elements in the stack: 5
Adding elements in the stack: 6
Adding elements in the stack: 7
Adding elements in the stack: 8
Adding elements in the stack: 9
Adding elements in the stack: 10
Adding elements in the stack: 11
Adding elements in the stack: 12
Adding elements in the stack: 13
Adding elements in the stack: 14
Adding elements in the stack: 15
Removing elements at the top of stack: 15
Removing elements at the top of stack: 14
Removing elements at the top of stack: 13
Removing elements at the top of stack: 12
Removing elements at the top of stack: 11
Removing elements at the top of stack: 10
Removing elements at the top of stack: 9
Removing elements at the top of stack: 8
Removing elements at the top of stack: 7
Removing elements at the top of stack: 6
Element at the top of stack is : 5

Use Cases of Stack :

If you want to reverse a word then push each letter of this word in stack and then use pop operation to remove and return letter from the stack and concatenate these letters to form a word. You will get reverse word.
Undo operation in MSWord document uses stack by pushing all the changes in stack and last change will be at the top of stack. When you redo changes then last applied change will be returned and removed from stack and rollback last changes in the MSWord document
Back button is there in each web browser. When you redirected from one page to other page then those pages are pushed to stack using push operation. Current page is at the top of stack and when you press back button of browser then you will be redirected in reverse order through the pages in stack from top to bottom.
Stack is used in Depth First search(DFS)
JVM uses stack in memory management. Stack memory is used for thread execution. Whenever a method is called then a new frame is created in the stack for that method to hold local variables and reference to other objects.

What is ReentrantLock?

May 4, 2017 By j2eereference Leave a Comment

ReentrantLock is an implementation of Lock interface and comes under java.util.concurrent.locks. ReentrantLock concept is same as traditional synchronized methods but it has more capability like fairness approach,Lock interruptibly ,tryLock and other features which we will discuss under important method of ReentrantLock section.

Constructors:

ReentrantLock() : this constructor is used to create instance of ReentrantLock which means fair value is false .

ReentrantLock(boolean fair): this construct will create instance of ReentrantLock which accept Boolean value as parameter either true or false.

If boolean variable fair is true it means that thread which is waiting from long will get the lock first

If boolean variable flag is false then it means any thread can get the lock .

Example:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {
  public static void main(String[] args) {
   Lock lock = new ReentrantLock();
   WorkerThread workerThread = new WorkerThread(lock);
   new Thread(workerThread, "WorkerThread1").start();
   new Thread(workerThread, "WorkerThread2").start();
   new Thread(workerThread, "WorkerThread3").start();
 }
}

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {

public static void main(String[] args) {

Lock lock = new ReentrantLock();

WorkerThread workerThread = new WorkerThread(lock);

new Thread(workerThread, "WorkerThread1").start();

new Thread(workerThread, "WorkerThread2").start();

new Thread(workerThread, "WorkerThread3").start();

}

class WorkerThread implements Runnable {
   Lock lock;
   public WorkerThread(Lock lock) {
   this.lock = lock;
 }

  public void run() {
   lock.lock();
   System.out.println("Lock has been acquired by "+ Thread.currentThread().getName());
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
     e.printStackTrace();
   }
   System.out.println("Lock has been released by "+ Thread.currentThread().getName());
   lock.unlock();
  }
}

class WorkerThread implements Runnable {

Lock lock;

public WorkerThread(Lock lock) {

this.lock = lock;

}

public void run() {

lock.lock();

System.out.println("Lock has been acquired by "+ Thread.currentThread().getName());

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Lock has been released by "+ Thread.currentThread().getName());

lock.unlock();

}

Output:
Lock has been acquired by WorkerThread1
Lock has been released by WorkerThread1
Lock has been acquired by WorkerThread2
Lock has been released by WorkerThread2
Lock has been acquired by WorkerThread3
Lock has been released by WorkerThread3

Important Methods:

1) void lock() : This method will cause current thread to hold the lock if it is not acquired by other thread otherwise current thread will wait until acquired lock gets released by other thread.
One more scenario is that lock hold count would increased by 1 in case lock is already held by current thread
2)void unlock(): If current thread calls unlock method then lock is released if lock hold count is zero and if it greater than 0 then lock hold count get decremented by 1.
3)boolean tryLock(): This method will acquires lock and return true if lock is not held by any thread otherwise returns false.
4)boolean tryLock(long timeout, TimeUnit unit):This method will wait for the lock to become available until time mentioned in the method timeouts.
5)void lockInterruptibly():This method allows the thread to immediately react to the interrupt signal sent by other thread and throw interrupted exception.
6)getHoldCount() :This method will give you hold count on this lock by the current thread.
7)isHeldByCurrentThread() :This method will check whether current thread holds the lock .

What is Semaphore in java

May 2, 2017 By j2eereference Leave a Comment

A semaphore is a technique used to restrict the number of simultaneous threads on a shared resource up to a maximum number. It maintains a counter called permits which keeps track of the number of resources available. Semaphore is just a gatekeeper guarding the resources .If permits available then grants access to shared resources otherwise ask the threads to wait.

Example:

Lets understand the usage with a simple program below. Here we have 2 printers and 10 threads are trying to access the same printers. Each thread will be able to use the printer only if any printer is available.

import java.util.concurrent.Semaphore;

public class SemaphoreDemo{

	public static void main(String[] args) {		
		Semaphore printerSem=new Semaphore(2);
		PrinterSemaphore printerSemObj=new PrinterSemaphore(printerSem);
		for(int i=1;i<=10;i++){
			new Thread(printerSemObj, "User"+i).start();
		}
	}
}

import java.util.concurrent.Semaphore;

public class SemaphoreDemo{

public static void main(String[] args) {

Semaphore printerSem=new Semaphore(2);

PrinterSemaphore printerSemObj=new PrinterSemaphore(printerSem);

for(int i=1;i<=10;i++){

new Thread(printerSemObj, "User"+i).start();

}

import java.util.concurrent.Semaphore;

public class PrinterSemaphore implements Runnable{
	Semaphore printerSem;
	PrinterSemaphore(Semaphore printerSem){
		this.printerSem=printerSem;
	}
	@Override
	public void run() {
		try {
			printerSem.acquire();
			System.out.println(Thread.currentThread().getName()+" is Using the printer");
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+" Releasing the printer");
		printerSem.release();
	}
}

import java.util.concurrent.Semaphore;

public class PrinterSemaphore implements Runnable{

Semaphore printerSem;

PrinterSemaphore(Semaphore printerSem){

this.printerSem=printerSem;

}

@Override

public void run() {

try {

printerSem.acquire();

System.out.println(Thread.currentThread().getName()+" is Using the printer");

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+" Releasing the printer");

printerSem.release();

}

Output:

User1 is Using the printer
User2 is Using the printer
User1 Releasing the printer
User2 Releasing the printer
User3 is Using the printer
User4 is Using the printer
User3 Releasing the printer
User4 Releasing the printer
User5 is Using the printer
User7 is Using the printer
User5 Releasing the printer
User7 Releasing the printer
User6 is Using the printer
User9 is Using the printer
User9 Releasing the printer
User6 Releasing the printer
User8 is Using the printer
User10 is Using the printer
User8 Releasing the printer
User10 Releasing the printer

Here you can notice that only two threads are getting access to the printer at a time.

Important methods :

acquire():If permits are available then threads can access shared resources by calling acquire() method.

release(): Once the thread is finished using resource, it returns back the permit using release() method of Semaphore

availablePermits(): This method returns the available number of permit at any time.

Real time use cases :

Consider an ATM cubicle with 2 ATM machines and can allow only 2 people to access machine simultaneously.
For implementing Producer Consumer pattern
One book can be issued to only one reader at a time in a Library.

Why AtomicInteger class

April 27, 2017 By j2eereference 1 Comment

AtomicInteger class belongs to java.util.concurrent.atmoic package which contain many classes like AtomicInteger,AtomicLong and AtomicBoolean.AtomicInteger is a class that provides you an int value which can be read and write atomically by many threads without interrupting each other

An atomic operation is one which gives guarantee that operation will not get interrupted in between by the thread scheduler .

Atomic classes internally using CAS (compare and swap) algorithm.

How it works in Multi threaded environment ?

Lets see how the below program works in the multi threaded environment with primitive int data type

class Count 
{
	public static int countIntValue=0;
}
public class RunnableAtomicIntegerDemo extends Thread{
	@Override
	public void run() { 
		Count.countIntValue++;
		System.out.print( Count.countIntValue+"  ");
	}
	public static void main(String[] args) {
		for(int i=0;i<=15;i++){
			new Thread(new RunnableAtomicIntegerDemo()).start();
		}
	}
}

class Count

{

public static int countIntValue=0;

}

public class RunnableAtomicIntegerDemo extends Thread{

@Override

public void run() {

Count.countIntValue++;

System.out.print( Count.countIntValue+" ");

}

public static void main(String[] args) {

for(int i=0;i<=15;i++){

new Thread(new RunnableAtomicIntegerDemo()).start();

}

Output :

5 9 10 8 7 7 7 7 7 6 11 12 13 14 16 16

Here you can notice that we have duplicate values because of the multiple thread access. This can be avoided by the following program with the use of Synchronized block.

class Count 
{
	public static int countIntValue=0;
}
public class RunnableAtomicIntegerDemo extends Thread{
	@Override
	public void run() { 
		synchronized (Count.class) {
			Count.countIntValue++;
			System.out.print( Count.countIntValue+"  ");
		}
	}
	public static void main(String[] args) {
		for(int i=0;i<=15;i++){
			new Thread(new RunnableAtomicIntegerDemo()).start();
		}
	}
}

class Count

{

public static int countIntValue=0;

}

public class RunnableAtomicIntegerDemo extends Thread{

@Override

public void run() {

synchronized (Count.class) {

Count.countIntValue++;

System.out.print( Count.countIntValue+" ");

}

public static void main(String[] args) {

for(int i=0;i<=15;i++){

new Thread(new RunnableAtomicIntegerDemo()).start();

}

Output:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Here we don’t have any duplicate values as we used Synchronized block.

Here comes the benefit of using Atomic classes. Lets see how the above program can be implemented easily by using AtomicInteger class.

import java.util.concurrent.atomic.AtomicInteger;

class Count 
{
	public static AtomicInteger countValue=new AtomicInteger(0);
}
public class RunnableAtomicIntegerDemo extends Thread{
	@Override
	public void run() { 
			System.out.print("   "+Count.countValue.incrementAndGet());
	}
	public static void main(String[] args) {
		for(int i=0;i<=15;i++){
			new Thread(new RunnableAtomicIntegerDemo()).start();
		}
	}
}

import java.util.concurrent.atomic.AtomicInteger;

class Count

{

public static AtomicInteger countValue=new AtomicInteger(0);

}

public class RunnableAtomicIntegerDemo extends Thread{

@Override

public void run() {

System.out.print(" "+Count.countValue.incrementAndGet());

}

public static void main(String[] args) {

for(int i=0;i<=15;i++){

new Thread(new RunnableAtomicIntegerDemo()).start();

}

Output:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Program to demonstrate different methods :

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerDemo {
	public static void main(String[] args) {
		AtomicInteger atomicInt = new AtomicInteger(5);
		System.out.println("Value returned by get() is " + atomicInt.get());
		atomicInt.set(7);
		System.out.println("Value returned after calling set(7) is "+ atomicInt.get());
		System.out.println("Value returned on calling getAndSet(10) is "+ atomicInt.getAndSet(10));
		System.out.println("Value returned after calling getAndSet(10) is "+ atomicInt.get());
		atomicInt.addAndGet(5);
		System.out.println("Value returned after calling addAndGet(5) is "+ atomicInt.get());
		atomicInt.incrementAndGet();
		System.out.println("Value returned after calling incrementAndGet() is "+ atomicInt.get());
		atomicInt.decrementAndGet();
		System.out.println("Value returned after calling decrementAndGet() is "+ atomicInt.get());
		atomicInt.compareAndSet(15, 20);
		System.out.println("Value returned after calling compareAndSet(15,20) is "+ atomicInt.get());
	}
}

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerDemo {

public static void main(String[] args) {

AtomicInteger atomicInt = new AtomicInteger(5);

System.out.println("Value returned by get() is " + atomicInt.get());

atomicInt.set(7);

System.out.println("Value returned after calling set(7) is "+ atomicInt.get());

System.out.println("Value returned on calling getAndSet(10) is "+ atomicInt.getAndSet(10));

System.out.println("Value returned after calling getAndSet(10) is "+ atomicInt.get());

atomicInt.addAndGet(5);

System.out.println("Value returned after calling addAndGet(5) is "+ atomicInt.get());

atomicInt.incrementAndGet();

System.out.println("Value returned after calling incrementAndGet() is "+ atomicInt.get());

atomicInt.decrementAndGet();

System.out.println("Value returned after calling decrementAndGet() is "+ atomicInt.get());

atomicInt.compareAndSet(15, 20);

System.out.println("Value returned after calling compareAndSet(15,20) is "+ atomicInt.get());

}

OutPut:
Value returned by get() is 5
Value returned after calling set(7) is 7
Value returned on calling getAndSet(10) is 7
Value returned after calling getAndSet(10) is 10
Value returned after calling addAndGet(5) is 15
Value returned after calling incrementAndGet() is 16
Value returned after calling decrementAndGet() is 15
Value returned after calling compareAndSet(15,20) is 20

Important methods :

1)int get() : This method will return current value of AtomicInteger
2)void set(int value) : This method will set the given value in AtomicInteger
3)int getAndSet(int newValue) : This method will set the given value and then returns the old value defined in AtomicInteger constructor.
4)int addAndGet(int value) : Method will add the given value in the value defined in AtomicInteger Constructor and returns the updated value.
5)int incrementAndGet() : This method will increment the value given in AtomicInteger by 1 and return the updated value.
6)boolean compareAndSet(int expect, int update) : Method will Compare the value given in Atomic class constructor with the expect value given in the method and if both are equal then set to update value and returns true.
7)int decrementAndGet():This method will decrements the value given in AtomicInteger by 1 and return the updated value.

Advantages of Atomic classes:

It will be very useful when you are working in multithreading environment and required to perform thread safe operations on integer without taking any lock(synchronized method)
Operations are fast and more readable than primitive synchronized methods.
It provides many operations like increment and decrement on integer variable which is shared between many threads and hence minimizing the need of complex multithreading.

What is CyclicBarrier?

April 25, 2017 By j2eereference 4 Comments

CyclicBarrier is another concurrency utility introduced in JDK 1.5 , Whis is a java synchronizer that allows two or more threads to wait for each other at a common point known as the barrier before it starts processing.
When all threads have reached barrier point then all waiting threads are released, and if any Runnable action is defined then it will be triggered as well.

CyclicBarrier’s constructor

There are two constructors with the below parameters.

(int parties) : Here parties is the number of threads need to wait at barrier.
(int parties, Runnable barrierAction) : The second parameter is the barrier action which will get executed after all threads have reached common barrier point.

Important methods:

await();This method is similar to countdown() method of CountDownLatch .This method is called on the CyclicBarrier object in the thread which is to be paused. If there are 4 threads that must pause at barrier point then await() must be called in the run() of those threads when the last thread (4) calls the await() method, after that every thread should wake up and start processing.
await(long time,TimeUnit units):This method is same as the above method but the thread here is paused for a given time If barrier is broken before a thread calls await() then this method will throw BrokenBarrierException.

reset(); This method resets the barrier to the initial state.

How it works ?

Create instance of CyclicBarrier and initialized it with 4(working threads), this is actually number of threads need to wait at barrier. The barrier will not be broken until all threads are arrived. A thread is said to be arrived when it calls await() method.

In below program, we will use four worker threads and one main thread, which is running your main method. We have given each thread a different name, starting from Thread-1 to Thread-4 just to have a better understanding. Now pass same instance of the cyclic barrier to each thread. In run method implementation we define sleep method that causes each thread to sleep for some seconds and then call await() method on the barrier.

Example:

In below program, we will use four worker threads and one main thread, which is running your main method

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
	public static void main(String[] args) {

		CyclicBarrier cyclicBarrier=new CyclicBarrier(4 ,new RunnableAction());
		System.out.println("Created CyclicBarrier with 4 threads and Runnable Action will be triggered when all "
				+ "4 threads will reach at common barrier point ");
		// Creating and starting 4 threads
		for(int i=1;i<=4;i++){
			new Thread(new CyclicRunnable(cyclicBarrier),"Thread-"+i).start();
		}

	}

}

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {

public static void main(String[] args) {

CyclicBarrier cyclicBarrier=new CyclicBarrier(4 ,new RunnableAction());

System.out.println("Created CyclicBarrier with 4 threads and Runnable Action will be triggered when all "

+ "4 threads will reach at common barrier point ");

// Creating and starting 4 threads

for(int i=1;i<=4;i++){

new Thread(new CyclicRunnable(cyclicBarrier),"Thread-"+i).start();

}

class RunnableAction implements Runnable{

	@Override
	public void run()
	{
		System.out.println("Runnable Action will be triggered when all the threads reach barrier point");
	}
}

class RunnableAction implements Runnable{

@Override

public void run()

{

System.out.println("Runnable Action will be triggered when all the threads reach barrier point");

}

class CyclicRunnable implements Runnable{

	private CyclicBarrier cyclicBarrier;

	CyclicRunnable(CyclicBarrier cyclicBarrier){
		this.cyclicBarrier=cyclicBarrier;
	}

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() +" is arrived at common barrier point");
		try {
			Thread.sleep(1000);
			cyclicBarrier.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			e.printStackTrace();
		}

		System.out.println(Thread.currentThread().getName() + " has been released for further processing");
	}
}

class CyclicRunnable implements Runnable{

private CyclicBarrier cyclicBarrier;

CyclicRunnable(CyclicBarrier cyclicBarrier){

this.cyclicBarrier=cyclicBarrier;

}

@Override

public void run() {

System.out.println(Thread.currentThread().getName() +" is arrived at common barrier point");

try {

Thread.sleep(1000);

cyclicBarrier.await();

} catch (InterruptedException e) {

e.printStackTrace();

} catch (BrokenBarrierException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + " has been released for further processing");

}

Output:
Created CyclicBarrier with 4 threads and Runnable Action will be triggered when all 4 threads will reach at common barrier point
Thread-1 is arrived at common barrier point
Thread-3 is arrived at common barrier point
Thread-2 is arrived at common barrier point
Thread-4 is arrived at common barrier point
Runnable Action will be triggered when all the threads reach barrier point
Thread-1 has been released for further processing
Thread-4 has been released for further processing
Thread-2 has been released for further processing
Thread-3 has been released for further processing

Realtime Use cases :

Multiplayer video game, game is started only when all players joined.
If you are going to a picnic, and you need to first meet at some common point from where you all will start your journey.
It can be used where big task is broken down into smaller tasks and to complete the job you need output from individual small task

Differences between CountDownLatch and CyclicBarrier:

CyclicBarrier has reset method which is not present in CountDownLatch,so CyclicBarrier can be used again once count becomes 0
CyclicBarrier has constructor that defines Runnable event,so it can be use to trigger Runnable event once counter becomes 0 but CountDownLatch cant not do this. Refer countDownLatch

CountDownLatch in java

April 24, 2017 By j2eereference 3 Comments

CountDownLatch is a java synchronizer that comes under java.util.concurrent package and is available in java from jdk 1.5.

It is used in the scenario where multiple threads are working together and one or more threads need to wait until a set of task is finished by other threads.

Important methods used
await() ; The current thread which called this method will go into waiting state and will wait until the count becomes 0.

CountDown() ;This method when called will decrements the count and when count becomes 0, the current thread will notify the thread which called await() on the same CountDownLatch instance.

getCount() : This method will return the current count.

How it works:

When we create an object of CountDownLatch, we pass an int value to its constructor which specify the number of threads it should wait for, all the thread are required to decrement this count by calling countDown() . As soon as count becomes zero, the waiting thread on which await method is called completes its waiting time and resumes further processing.

Example application

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample{
	public static void main(String args[]) throws InterruptedException
	{
		CountDownLatch latch = new CountDownLatch(3);
		System.out.println("Initial count is :"+latch.getCount());
		// Let us create three worker threads (subTask-1,subtask-2 and subTask-3)and start them.
		for(int i=0;i<=2;i++){
			new Thread(new MyRunnableDemo(latch),"subTask-"+i).start();
		}

		// The main task wait for three threads
		latch.await();
		System.out.println("count after completing all subtasks is :"+latch.getCount());
		// Main thread has started
		System.out.println("All sub tasks are finished and the main thread is starting now ...");
		Thread.sleep(1000);
		System.out.println(Thread.currentThread().getName() +" thread has finished");
	}
}

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample{

public static void main(String args[]) throws InterruptedException

{

CountDownLatch latch = new CountDownLatch(3);

System.out.println("Initial count is :"+latch.getCount());

// Let us create three worker threads (subTask-1,subtask-2 and subTask-3)and start them.

for(int i=0;i<=2;i++){

new Thread(new MyRunnableDemo(latch),"subTask-"+i).start();

}

// The main task wait for three threads

latch.await();

System.out.println("count after completing all subtasks is :"+latch.getCount());

// Main thread has started

System.out.println("All sub tasks are finished and the main thread is starting now ...");

Thread.sleep(1000);

System.out.println(Thread.currentThread().getName() +" thread has finished");

}

import java.util.concurrent.CountDownLatch;

class MyRunnableDemo implements Runnable
{
	private CountDownLatch latch;
	public MyRunnableDemo(CountDownLatch latch)
	{
		this.latch = latch;
	}
	@Override
	public void run() { 
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+" finished the task");
		latch.countDown();
	}
}

import java.util.concurrent.CountDownLatch;

class MyRunnableDemo implements Runnable

{

private CountDownLatch latch;

public MyRunnableDemo(CountDownLatch latch)

{

this.latch = latch;

}

@Override

public void run() {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+" finished the task");

latch.countDown();

}

OutPut :

Initial count is :3
subTask-0 finished the task
subTask-1 finished the task
subTask-2 finished the task
count after completing all subtasks is :0
All sub tasks are finished and the main thread is starting now …
main thread has finished

Real-time use cases

In an amusement park, there are certain rides in which it is mandate to have atleast 2 people (2 is count) to share seat in order to take that ride. So, ride keeper waits for 2 persons for each seat so that he can start the ride.

Suppose a big heavy rectangular box can be lifted by 4 people from four corners, so you will wait for all 4 to come then only you can lift that heavy box.

Prototype design pattern

April 6, 2017 By j2eereference Leave a Comment

Prototype design pattern

The idea of prototype pattern is having a blueprint from which we can create multiple instances.

When to use Prototype design pattern

This pattern can be used when creation of object is costly. For example, Consider a class which required configuration data from a file / database / over a network for initializing. This kind of operations make the object creation very costly especially if you want to create multiple objects of such type. The best solution for this problem is to use the Prototype design pattern – Create the object once and create the subsequent objects by cloning this object.

What are the benefits of using prototype design patterns

Prototype pattern helps us mainly in Time and Memory saving.

Time :

Creating the object once and create the subsequent objects by cloning this object helps reducing the time for creating the objects.

Memory :

Consider an object which has more number of String objects, creating a new instance would need to create entirely new immutable strings . By Using the prototype pattern we can avoid this problem by cloning the already created object.

Implementation of prototype pattern:

Lets understand the implementation of prototype design pattern with a simple example. This example is just for understanding the concept. The benefit you are going to get by using the prototype design pattern in real time applications will be more than this example.

Here we have a Box class and we need to create multiple instances of the BOX class. These objects are different only in colors.

Box.java

package com.j2eereference.designPattern.prototype;

public class Box implements Cloneable {
	private int width;
	private int length;
	private int depth;
	String color;

	Box(int width,int length,int depth){
		this.width=width;
		this.length=length;
		this.depth=depth;		
	}

	public int getWidth() {
		return width;
	}
	public void setWidth(int width) {
		this.width = width;
	}
	public int getLenght() {
		return length;
	}
	public void setLenght(int lenght) {
		this.length = lenght;
	}
	public int getDeptht() {
		return depth;
	}
	public void setDeptht(int deptht) {
		this.depth = deptht;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public Box clone() throws CloneNotSupportedException {
		Box cloned = (Box)super.clone();
		return cloned;
	}
	@Override
	public String toString() {		
		return "Width :"+width+" Length : "+length+" Color : "+color;
	}
}

package com.j2eereference.designPattern.prototype;

public class Box implements Cloneable {

private int width;

private int length;

private int depth;

String color;

Box(int width,int length,int depth){

this.width=width;

this.length=length;

this.depth=depth;

}

public int getWidth() {

return width;

}

public void setWidth(int width) {

this.width = width;

}

public int getLenght() {

return length;

}

public void setLenght(int lenght) {

this.length = lenght;

}

public int getDeptht() {

return depth;

}

public void setDeptht(int deptht) {

this.depth = deptht;

}

public String getColor() {

return color;

}

public void setColor(String color) {

this.color = color;

}

public Box clone() throws CloneNotSupportedException {

Box cloned = (Box)super.clone();

return cloned;

}

@Override

public String toString() {

return "Width :"+width+" Length : "+length+" Color : "+color;

}

PrototypeDemo.java

package com.j2eereference.designPattern.prototype;

public class PrototypeDemo {
	public static void main(String[] args) {
		Box box=new Box(10,10, 10);
		try {
			Box redBox=box.clone();			
			redBox.setColor("RED");

			Box greenBox=box.clone();			
			greenBox.setColor("GREEN");

			System.out.println(redBox);
			System.out.println(greenBox);

		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	}

}

package com.j2eereference.designPattern.prototype;

public class PrototypeDemo {

public static void main(String[] args) {

Box box=new Box(10,10, 10);

try {

Box redBox=box.clone();

redBox.setColor("RED");

Box greenBox=box.clone();

greenBox.setColor("GREEN");

System.out.println(redBox);

System.out.println(greenBox);

} catch (CloneNotSupportedException e) {

e.printStackTrace();

}

Output:

Width :10 Length : 10 Color : RED

Width :10 Length : 10 Color : GREEN

Here you can notice that we created the blueprint of Box and did color property settings for creating different objects. This pattern will be more useful if the initialization is costly.

Interface changes in java 8

April 3, 2017 By j2eereference Leave a Comment

Interface changes in Java 8

One of the biggest design changes in Java 8 is with the concept of interfaces. Prior to version 8, Java supported only method declarations in interfaces. But from Java 8, we can have default methods in the interfaces,which can have implementation as well.

Let’s take an example : The below code will compile in Java 8.

public interface java8Interface {
	default public void display(){
		System.out.println("Inside [java8Interface] [display] ");
	}	
}


public class Java8InterfaceImpl implements java8Interface {
	public void draw(){
		System.out.println("[Java8InterfaceImpl][draw]");
	}
}


public class TestInterface {
	public static void main(String[] args) {
		Java8InterfaceImpl interfaceImpl= new Java8InterfaceImpl();
		interfaceImpl.display();
	}
}

public interface java8Interface {

default public void display(){

System.out.println("Inside [java8Interface] [display] ");

}

public class Java8InterfaceImpl implements java8Interface {

public void draw(){

System.out.println("[Java8InterfaceImpl][draw]");

}

public class TestInterface {

public static void main(String[] args) {

Java8InterfaceImpl interfaceImpl= new Java8InterfaceImpl();

interfaceImpl.display();

}

Output:

Inside [java8Interface] [display]

Why Defaut Method?

Modifying an interface in any application framework breaks all classes that implements the interface . For example adding any new method in an existing interface could break lots of lines of code. Default methods can be added to an interface without affecting implementing classes as it includes an implementation. If each added method in an interface defined with implementation then no implementing class is affected. An implementation class can also override the default implementation provided by the interface. Default methods will help us in extending interfaces without having the fear of breaking implementation classes.

Default Method and ambiguity Problem

Lets understand the ambiguity issue with the below example code.

public interface Java8InterfaceA {
	default public void display(){
		System.out.println("Inside [java8InterfaceA] [display] ");
	}
}

public interface Java8InterfaceB {
	default public void display(){
		System.out.println("Inside [java8InterfaceB] [display] ");
	}
}

public class Java8InterfaceImpl implements Java8InterfaceA,Java8InterfaceB {
	
}

public interface Java8InterfaceA {

default public void display(){

System.out.println("Inside [java8InterfaceA] [display] ");

}

public interface Java8InterfaceB {

default public void display(){

System.out.println("Inside [java8InterfaceB] [display] ");

}

public class Java8InterfaceImpl implements Java8InterfaceA,Java8InterfaceB {

}

As mentioned in the above code, if we try to implement two interfaces which are having same methods , we will get compilation error as below.

Duplicate default methods named display with the parameters () and () are inherited from the types Java8InterfaceB and Java8InterfaceA

In order to fix this error we need to provide default method implementation:

public class Java8InterfaceImpl implements Java8InterfaceA,Java8InterfaceB {
	@Override
	public void display() {
	}
}

public class Java8InterfaceImpl implements Java8InterfaceA,Java8InterfaceB {

@Override

public void display() {

}

Further, if we want to invoke default implementation provided by any of super interfaces rather than your own implementation, we can do so as follows,

public class Java8InterfaceImpl implements Java8InterfaceA,Java8InterfaceB {
	@Override
	public void display() {
		Java8InterfaceA.super.display();
	}
}

public class Java8InterfaceImpl implements Java8InterfaceA,Java8InterfaceB {

@Override

public void display() {

Java8InterfaceA.super.display();

}

Generics wildcard arguments

July 16, 2015 By j2eereference Leave a Comment

Generics wildcard arguments

The wildcard ? in Java is a special actual parameter for the instantiation of generic types.

Let’s understand this with an example:

Consider two classes called CompAEmp and CompBEmp extending Emp class. We have a generic class called MyEmployeeUtil, where we have utilities to perform employee functions irrespective of which comapany emp belogns too. This class accepts subclasses of Emp. In case if we want to compare salaries of two employees, how can we do using MyEmployeeUtil class?

U can think that below sample code might work, but it wont work.

public boolean isSalaryEqual(MyEmployeeUtil otherEmp)
{     
    if(emp.getSalary() == otherEmp.getSalary())
    {
        return true;
    }
    return false;
}

public boolean isSalaryEqual(MyEmployeeUtil otherEmp)

{

if(emp.getSalary() == otherEmp.getSalary())

{

return true;

}

return false;

}

Because once you create an object of MyEmp class, the type argument will be specific to an instance type. So you can compare between only same object types, ie, you can comapare either objects of CompAEmp or CompBEmp, but not between CompAEmp and CompBEmp. To solve this problem, wildcard argument will helps you. Look at below sample code, which can solve your problem.

public boolean isSalaryEqual(MyEmployeeUtil<?>  otherEmp)
{     
    if(emp.getSalary() == otherEmp.getSalary())
    {
        return true;
    }
    return false;
}

public boolean isSalaryEqual(MyEmployeeUtil<?> otherEmp)

{

if(emp.getSalary() == otherEmp.getSalary())

{

return true;

}

return false;

}

In the above example MyEmployeeUtil means class typed to unknown type. This could be MyEmployeeUtil

Here is complete program example:

package com.j2eereference.generics;
 
public class MyWildcardEx 
{ 
    public static void main(String a[])
    {         
        MyEmployeeUtil empA = new MyEmployeeUtil(new CompAEmp("Ram", 20000));
        MyEmployeeUtil empB = new MyEmployeeUtil(new CompBEmp("Krish", 30000));
        MyEmployeeUtil empC = new MyEmployeeUtil(new CompAEmp("Nagesh", 20000));
        System.out.println("Is salary same? "+empA.isSalaryEqual(empB));
        System.out.println("Is salary same? "+empA.isSalaryEqual(empC));
    }
} 
class MyEmployeeUtil
{    
    private T emp;
    public MyEmployeeUtil(T obj)
    {
        emp = obj;
    }
    public int getSalary()
    {
        return emp.getSalary();
    }
    public boolean isSalaryEqual(MyEmployeeUtil<?> otherEmp)
    {    
        if(emp.getSalary() == otherEmp.getSalary()){
            return true;
        }
        return false;
    }
}
 
class Emp{
     
    private String name;
    private int salary;
     
    public Emp(String name, int sal){
        this.name = name;
        this.salary = sal;
    }
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getSalary() {
        return salary;
    }
    public void setSalary(int salary) {
        this.salary = salary;
    }
}
 
class CompAEmp extends Emp{
     
    public CompAEmp(String nm, int sal){
        super(nm, sal);
    }
}
 
class CompBEmp extends Emp{
     
    public CompBEmp(String nm, int sal){
        super(nm, sal);
    }
}

package com.j2eereference.generics;

public class MyWildcardEx

{

public static void main(String a[])

{

MyEmployeeUtil empA = new MyEmployeeUtil(new CompAEmp("Ram", 20000));

MyEmployeeUtil empB = new MyEmployeeUtil(new CompBEmp("Krish", 30000));

MyEmployeeUtil empC = new MyEmployeeUtil(new CompAEmp("Nagesh", 20000));

System.out.println("Is salary same? "+empA.isSalaryEqual(empB));

System.out.println("Is salary same? "+empA.isSalaryEqual(empC));

}

class MyEmployeeUtil

{

private T emp;

public MyEmployeeUtil(T obj)

{

emp = obj;

}

public int getSalary()

{

return emp.getSalary();

}

public boolean isSalaryEqual(MyEmployeeUtil<?> otherEmp)

{

if(emp.getSalary() == otherEmp.getSalary()){

return true;

}

return false;

}

class Emp{

private String name;

private int salary;

public Emp(String name, int sal){

this.name = name;

this.salary = sal;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getSalary() {

return salary;

}

public void setSalary(int salary) {

this.salary = salary;

}

class CompAEmp extends Emp{

public CompAEmp(String nm, int sal){

super(nm, sal);

}

class CompBEmp extends Emp{

public CompBEmp(String nm, int sal){

super(nm, sal);

}

Bounded Wildcard:

A bounded wildcard is one with either an upper or a lower constraint. Wildcard can be constrained if one doesn’t want to be compatible with all instantiations:

Genericextends SubtypeOfUpperBound>

This reference can hold any instantiation of Generic with an actual type parameter of SubtypeOfUpperBound‘s subtype. A wildcard that does not have a constraint is effectively the same as one that has the constraint extends Object, since all types implicitly extend Object. A constraint with a lower bound

Genericsuper SubtypeOfUpperBound>

can hold instantiations of Generic with any supertype (e.g. UpperBound) of SubtypeOfUpperBound.

Example:

In the Java Collections Framework, the class List represents an ordered collection of objects of type MyClass. Upper bounds are specified using extends: AList is a list of objects of some subclass of MyClass, i.e. any object in the list is guaranteed to be of type MyClass, so one can iterate over it using a variable of type MyClass

public void doSomething(List<? extends MyClass> list)
{
	for(MyClass object:list)
	{
		// do something
	}
}

public void doSomething(List<? extends MyClass> list)

{

for(MyClass object:list)

{

// do something

}

However, it is not guaranteed that one can add any object of type MyClass to that list:

public void doSomething(List<? extends MyClass> list) 
{
  MyClass m = new MyClass();
  list.add(m); // Compile error
}

public void doSomething(List<? extends MyClass> list)

{

MyClass m = new MyClass();

list.add(m); // Compile error

}

The converse is true for lower bounds, which are specified using super: A List is a list of objects of some superclass of MyClass, i.e. the list is guaranteed to be able to contain any object of type MyClass, so one can add any object of type MyClass:

public void doSomething(List<? super MyClass> list) 
{
  MyClass m = new MyClass();
  list.add(m); // OK
}

public void doSomething(List<? super MyClass> list)

{

MyClass m = new MyClass();

list.add(m); // OK

}

However, it is not guaranteed that one can iterate over that list using a variable of type MyClass:

public void doSomething(List<? super MyClass> list) 
{
  for(MyClass object : list) // Compile error
  { 
    // do something
  }
}

public void doSomething(List<? super MyClass> list)

{

for(MyClass object : list) // Compile error

{

// do something

}

In order to be able to do both add objects of type MyClass to the list and iterate over it using a variable of type MyClass, a List<MyClass> is needed, which is the only type of List that is both List<? extends MyClass> and List<? super MyClass>.

Important points on Wildcard

1. Consider following program:

import java.util.ArrayList;
import java.util.List;

public class WildCardNumber
{
    public static void main(String[] args) 
	{
        List le = new ArrayList<>();
        List<? extends NaturalNumber> ln = le;
        ln.add(new NaturalNumber(50));//  *   Compile time error
        ln.add(new EvenNumber(46));   // **   Compile time error 
    }
}

class NaturalNumber 
{
    private int n;
    public NaturalNumber(int n) 
	{
        this.n = n;
    }
}

class EvenNumber extends NaturalNumber 
{
    public EvenNumber(int n) 
	{
        super(n);
    }
}

import java.util.ArrayList;

import java.util.List;

public class WildCardNumber

{

public static void main(String[] args)

{

List le = new ArrayList<>();

List<? extends NaturalNumber> ln = le;

ln.add(new NaturalNumber(50));// * Compile time error

ln.add(new EvenNumber(46)); // ** Compile time error

}

class NaturalNumber

{

private int n;

public NaturalNumber(int n)

{

this.n = n;

}

class EvenNumber extends NaturalNumber

{

public EvenNumber(int n)

{

super(n);

}

Why compile time error..?

Answer is:

The reason it’s fobidden is because if it was allowed:

List le = new ArrayList<>();
List<? extends NaturalNumber> ln = le;
ln.add(new NaturalNumber(50));
ln.add(new EvenNumber(46));  
EvenNumber even = le.get(0); // ClassCastException

List le = new ArrayList<>();

List<? extends NaturalNumber> ln = le;

ln.add(new NaturalNumber(50));

ln.add(new EvenNumber(46));

EvenNumber even = le.get(0); // ClassCastException

We are guaranteed by le declaration that all numbers must be even numbers. But if you’re allowed to add a NaturalNumber there then this guarantee breaks.

2. How WildCard works

void printCollection(Collection<Object> c) 
{
    for (Object e : c) 
	{
        System.out.println(e);
    }
}

void printCollection(Collection<Object> c)

{

for (Object e : c)

{

System.out.println(e);

}

void printCollection(Collection<?> c) {
    for (Object e : c) {
        System.out.println(e);
    }
}

void printCollection(Collection<?> c) {

for (Object e : c) {

System.out.println(e);

}

A Collection<Object> can contain Object and subclasses of it, and since everything (including String) is a subclass of Object, you can add anything to such a collection. However, you cannot make any assumptions about its contents except that they’re Objects.On the other hand, A Collection<?> contains only instances of a specific unknown type and its subclasses, but since you don’t know which type it is, you cannot add anything except null.

Core Java

Related Posts

Related Posts

Related Posts

Related Posts

Related Posts

Related Posts

Related Posts

Prototype design pattern

Related Posts

Interface changes in Java 8

Why Defaut Method?

Default Method and ambiguity Problem

Related Posts

Generics wildcard arguments

Related Posts

Footer