Double check locking

Simple simulation of  muli-threading : few threads will read data from different sources and reduce them to get maximum from all the sources, An example of double check locking.

lets make a  prototype of above problem. we will not go and solve it for generic case, we will simply create two thread thread1 and thread2;  this two threads will read data from two different sources and will will use a shared variable to get maximum of two data sets. 

we will not go into details about what is singleton and double check locking, may be we see them in future post. in a sentence singleton is a design pattern that enable us to have only one   instantiation of an object. that means we can't create  object of that class using new when and when ever we need to have object.

So, our implementation logic goes as follows 

     1. start both the threads 

             find the max in each thread.

     next update the shared variable; the class which holds the shared variable is following singleton design pattern.

class ReduceNto1{

    int max=0;
    private static ReduceNto1 r1=null;
   
    public static  ReduceNto1 getInstance(){
        if(r1==null)                            
        {
            synchronized (ReduceNto1.class) {
                if(r1==null)
                r1=new ReduceNto1();
               
            }
       
        }
        return r1;
       
    }
   
    private ReduceNto1(){}
   
   
    public synchronized  void  setMax(int n){
   
       
        System.out.println("***"+n);
           
            if(n>max){
                max=n;
            }
           
       
    }   
       
   
   
    public int getMax(){
        return max;
    }

   
   
}

class MaxFinder implements  Runnable {

    int max=Integer.MIN_VALUE;
    int arr[];
   
    public MaxFinder(int arr[]){
        this.arr=arr;
    }
    public void run() {
      findMax();   
      System.out.println(max);
      System.out.println(Thread.currentThread().getName()+"****setting max from this thread to reduce*****"+max);
      ReduceNto1.getInstance().setMax(max);
     
    }


    public void findMax(){
       
       
        for(int i=0;i<arr.length;i++){
       
            if(arr[i]>max)
                max=arr[i];
        }
   
       
    }
   
    public int getMax(){
        return max;
    }
}



public class ConcurrentReadingFromNarray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
       
        int arr1[]={1,2,3,4,5,49,7,8,9,10};
        int arr2[]={11,12,13,14,15,16,17,18,19,20};
        Thread t1=new Thread(new MaxFinder(arr1));
        Thread t2=new Thread(new MaxFinder(arr2));
        t1.start();
        t2.start();
        try{
            t1.join();
            t2.join();
        }catch(Exception e){}
        System.out.println("Max No is : "+ReduceNto1.getInstance().getMax());

    }

}

Output:

20
49
Thread-0****setting max from this thread to reduce*****49
Thread-1****setting max from this thread to reduce*****20
***20
***49
Max No is : 49

Note:

I am  prone to  typo; please report them and I will try to update the posts accordingly.