/**
 * 
 * A sample code demonstrate how notify() and wait() interact with each other
 *
 */
public class ResourcePoolTester extends Thread
{    
    ResourcePool pool = null;
    int num;
    
    public ResourcePoolTester(ResourcePool pool, int num)
    {
        this.pool = pool;
        this.num = num;
    }
    
    public synchronized void run()
    {
        if(num>0){ // check out
            System.out.println("Thread [" + Thread.currentThread().getId() +
                               "] is about to check out resources of: " + num);
            pool.checkOut(num);
            
        }else{  // check in
            num = -num;
            System.out.println("Thread [" + Thread.currentThread().getId() +
                               "] is about to check in resources of: " + num);
            pool.checkIn(num);
            
        }
    }
    
    
    public static void main(String[] args)
    {
        
        // initialize the resource pool  
        ResourcePool pool = new ResourcePool(2);
        System.out.println("The pool starts with size of: " + pool.size());
        
        // 5 threads to check out resuorce from the pool
        ResourcePoolTester t1 = new ResourcePoolTester(pool, 1); 
        ResourcePoolTester t2 = new ResourcePoolTester(pool, 2); 
        ResourcePoolTester t3 = new ResourcePoolTester(pool, 3); 
        ResourcePoolTester t4 = new ResourcePoolTester(pool, 4); 
        ResourcePoolTester t5 = new ResourcePoolTester(pool, 5); 
        
        t1.start(); // returns immediately
        t2.start(); // going to wait
        t3.start(); // going to wait
        t4.start(); // going to wait
        t5.start(); // going to wait
        
        // 2 threads to check in resource into the pool
        ResourcePoolTester t6 = new ResourcePoolTester(pool, -6); 
        t6.start();
        try{
            Thread.sleep(1000);  // just a second
        }catch(Exception e){
        }
        ResourcePoolTester t7 = new ResourcePoolTester(pool, -9); 
        t7.start();
        
        try{
            t1.join();
            t2.join();
            t3.join();
            t4.join();
            t5.join();
            t6.join();
            t7.join();
        }catch(Exception e){
        }
        
        System.out.println("The pool ends up with size of: " + pool.size());
        
    }
}


class ResourcePool
{
    /**
     *  the count monitoring how many resource currently reside in the pool
     */
    private int count;

    public ResourcePool(int count){
        this.count = count;
    }
    
    public synchronized void checkOut(int num)
    {
        // check to see if there are enough resources? 
        while(count<num){
            System.out.println("Thread [" + Thread.currentThread().getId() +
                               "] is waiting with pool size = " + size());
            try{
                wait(); // wait until there are enough resources
            }catch(Exception e){                    
            }
            System.out.println("Thread [" + Thread.currentThread().getId() +
                               "] wakes up with pool size = " + size());
        }
        count -= num; // check-out
        System.out.println("Thread [" + Thread.currentThread().getId() +
                            "] returns with pool size = " + size());
    }
    
    public synchronized void checkIn(int num)
    {
        count += num; // check-in
        
        notify();
        
        System.out.println("Thread [" + Thread.currentThread().getId() +
                           "] checked in with pool size = " + size());
    }
    
    public synchronized int size(){
        return count;
    }
    
}