CareerCup

impressive!

I am not sure if you were looking for View as option. Which will disconnect external system from our table dependency. and any change in table will not be transparent to them.

you are correct and after this compiler removes the generic type and at runtime it is executed without specific type. This is called generic Eraser. I came to know this concept in interview itself.

Thanks @Ehsan for details.

This is not threadsafe as StringBuilder reference can be changed by any other thread.

The logic is if some number is top N in table then there will be (n-1) number more than that in table take a example
you have 9,8,7,6 in table as id and Top 2 will have only one number more than that so it is used

1 = SELECT COUNT(DISTINCT(Emp2.Salary))
FROM Employee Emp2
WHERE Emp2.Salary > Emp1.Salary

public class ConcurrentLRUCache<Key, Value> {
 
private final int maxSize;
private ConcurrentHashMap<Key, Value> map;
private ConcurrentLinkedQueue<Key> queue;
 
public ConcurrentLRUCache(final int maxSize) {
    this.maxSize = maxSize;
    map = new ConcurrentHashMap<Key, Value>(maxSize);
    queue = new ConcurrentLinkedQueue<Key>();
}
 
/**
 * @param key - may not be null!
 * @param value - may not be null!
 */
public void put(final Key key, final Value value) {
    if (map.containsKey(key)) {
        queue.remove(key); // remove the key from the FIFO queue
    }
 
    while (queue.size() >= maxSize) {
        Key oldestKey = queue.poll();
        if (null != oldestKey) {
            map.remove(oldestKey);
        }
    }
    queue.add(key);
    map.put(key, value);
}
 
/**
 * @param key - may not be null!
 * @return the value associated to the given key or null
 */
public Value get(final Key key) {
    return map.get(key);
}
}

Delete data by scheduler using cleanData method.

package com.learning.lru;

import java.util.ArrayList;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class MyLRUCache  {

	
	private ArrayList<Data>  dataHolder = new ArrayList<Data>();
	
	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
	
	private final long dataLifetime = 5000;
	

	public Data getData(int i) {
		
		try{
		lock.readLock().lock();
		if(dataHolder.size() == 0){
			System.out.println(" NO Data Found");
			return null;
		}
		 return dataHolder.get(i);
		}finally{
			lock.readLock().unlock();
		}
				
	}


	public boolean putData(Data d) {
		try{
			lock.writeLock().lock();
			  dataHolder.add(d);
			  return true;
			}finally{
				System.out.println(" Final Data size "+dataHolder.size());
				lock.writeLock().unlock();
				return false;
			}
	
	}


	public boolean cleanData() {
		int i=0;		
		if( dataHolder.size()==0){
			System.out.println(" NO Data to clean");
			return true;
		}else{
			System.out.println(" Data Size "+ dataHolder.size());
			System.out.println(" lock status "+lock.getReadHoldCount());
		}	
		try{
			lock.writeLock().lock();			
			for(Data d : dataHolder){
			  if(System.currentTimeMillis()-d.getTimeStamp().getTime() > dataLifetime){
				  //tempHolder.add(d);
				  dataHolder.remove(i);
				  i++;				  
			  }
			}				
			}finally{
				lock.writeLock().unlock();
				return false;
			}
	}

}

//Client code

package com.learning.lru;

import java.util.Date;

public class LRUClient {


	public static void main(String[] args) {
		
		MyLRUCache cache = new MyLRUCache();
		
		LRUClient client = new LRUClient();;
		Thread lruc = new Thread(client .new LRUConsumer(cache));
		
		Thread lrup = new Thread( client .new LRUProducer(cache));
		
		Thread lrucl = new Thread( client .new LRUCleaner(cache));
	
		lrup.start();
		
		lruc.start();

		lrucl.start();
		
		
		//use scheduled
	}
	
	class LRUConsumer implements Runnable{		
		MyLRUCache cache ;
		LRUConsumer(MyLRUCache cache ){
			this.cache=cache;
		}
		@Override
		public void run() {			
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}		
			System.out.println(" Consuming  Data ---------->>>>>>>>");
			while(true){
				for(int i=0; i<20;i++){
					//System.out.println(" DATA :>>>"+cache.getData(i));
				}		
			}
		}
	}

	class LRUProducer implements Runnable{		
		MyLRUCache cache ;
		LRUProducer(MyLRUCache cache ){
			this.cache=cache;
		}
		@Override
		public void run() {			
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(" Putting  Data ---------->>>>>>>>");
			for(int i=0; i<20;i++){				
				cache.putData( new Data(i, new Date(System.currentTimeMillis())));
			  }		
		}
	}
	
	class LRUCleaner implements Runnable{		
		MyLRUCache cache ;
		LRUCleaner(MyLRUCache cache ){
			this.cache=cache;
		}
		@Override
		public void run() {			
			try {
				
				while(true){
					//Thread.sleep(3000);
					System.out.println(" Cleaning Data ---------->>>>>>>>");
					cache.cleanData();
				}
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
	}
}

In Java definitely concurrent task processing. We need to pick up task concurrently and we can use threadpool or executors to consume these tasks and update the result. We need to take care the database access and query execution should be minimal time consuming.