deleted 1862 characters in body

Source Link

edited Jul 17, 2015 at 4:21

35.2k
13
134
238

Can someone please review this code for me.? I have not implemented all the methods for simplicity.

Original code:

Updated code:

/**
 * Implements a blocking bounded queue from a given non-blocking unbounded queue implementation
 */
abstract class DerivedQueue<E> implements Queue<E>
{
    DerivedQueue(Queue<E> queue, int size)
    {
        if(queue==null | size <0)
        {
            throw new RuntimeException("Bad Input");
        }
        fQueue = queue;
        fMaxSize = size;
    }
    
    
    
    Queue<E> fQueue;
    int fMaxSize ;
    int fCurrrentCnt;
    

    @Override
    public boolean isEmpty()
    {
        return (fCurrrentCnt==0);
    }

    public synchronized E remove()
    {
        while(fCurrrentCnt==0)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
            }
        }
           
        
        E elem =  fQueue.remove();
        fCurrrentCnt--;
        notifyAll();
        return elem;
    }

    @Override
    public synchronized  boolean add(E elem)
    {
        while(fCurrrentCnt== fMaxSize )
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
            }
        }
        
       boolean bool = fQueue.add(elem);
       notifyAll();
       return bool;

    }

}

Open questions apart from CR:

Would calling notifyAll() lead to multiple waiting threadthreads checking the while() condition at the same time .., and hence there is a possibility that before the while gets saitsfiedsatisfied, 2 threads are already out of it causing an outOfBound exception?
OR Or does the methods need to be marked synchronized at all, and instead I can use a synchronized block for reading or writing part of the array while the checking of constrained and waiting can remain unsynchronized?
Is theirthere a way to notify precisely only the consumer threads[waitingthreads (waiting in take]take) or only the producer[waiting input]producer (waiting input) threads in this example? notifyAll notifies all of them.

Can someone please review this code for me. I have not implemented all the methods for simplicity.

Original code:

Updated code:

/**
 * Implements a blocking bounded queue from a given non-blocking unbounded queue implementation
 */
abstract class DerivedQueue<E> implements Queue<E>
{
    DerivedQueue(Queue<E> queue, int size)
    {
        if(queue==null | size <0)
        {
            throw new RuntimeException("Bad Input");
        }
        fQueue = queue;
        fMaxSize = size;
    }
    
    
    
    Queue<E> fQueue;
    int fMaxSize ;
    int fCurrrentCnt;
    

    @Override
    public boolean isEmpty()
    {
        return (fCurrrentCnt==0);
    }

    public synchronized E remove()
    {
        while(fCurrrentCnt==0)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
            }
        }
           
        
        E elem =  fQueue.remove();
        fCurrrentCnt--;
        notifyAll();
        return elem;
    }

    @Override
    public synchronized  boolean add(E elem)
    {
        while(fCurrrentCnt== fMaxSize )
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
            }
        }
        
       boolean bool = fQueue.add(elem);
       notifyAll();
       return bool;

    }

}

Open questions apart from CR:

Would calling notifyAll() lead to multiple waiting thread checking the while() condition at the same time .. and hence there is a possibility that before the while gets saitsfied, 2 threads are already out of it causing outOfBound exception?
OR does the methods need to be marked synchronized at all, instead I can use a synchronized block for reading or writing part of the array while the checking of constrained and waiting can remain unsynchronized?
Is their a way to notify precisely only the consumer threads[waiting in take] or only the producer[waiting input] threads in this example? notifyAll notifies all of them

Can someone please review this code for me? I have not implemented all the methods for simplicity.

Open questions:

Would calling notifyAll() lead to multiple waiting threads checking the while() condition at the same time, and hence there is a possibility that before the while gets satisfied, 2 threads are already out of it causing an outOfBound exception? Or does the methods need to be marked synchronized at all, and instead I can use a synchronized block for reading or writing part of the array while the checking of constrained and waiting can remain unsynchronized?
Is there a way to notify precisely only the consumer threads (waiting in take) or only the producer (waiting input) threads in this example? notifyAll notifies all of them.

adds the original code to make existing answers still valid

Source Link

edited Oct 28, 2012 at 9:49

palacsint

30.4k
9
82
157

Original code:

    /**
     * Implements a blocking bounded queue from a given non-blocking unbounded queue implementation
     */
    abstract class DerivedQueue<E> implements Queue<E>
    {
        DerivedQueue(Queue<E> queue, int size)
        {
            if(queue==null | size <0)
            {
                throw new RuntimeException("Bad Input");
        }
    }
    fQueue = queue;
      fQueue  fSize = queue;size;
    }
     
     
  fMaxSize = size;
    Queue<E> fQueue;
    int fSize;
   } int fCnt;
     
    @Override
    public boolean addAll(Collection<? extends E> arg0)
    {
        return false;
    }

    Queue<E>@Override
 fQueue;   public boolean isEmpty()
    {
      int fMaxSize return (fCnt==0);
    }

    intpublic fCurrrentCnt;E remove()
    {
        
 if(fCnt==0)
        @Override{
        public boolean isEmpty()  try
            {
            return    wait(fCurrrentCnt==0);
            }
 
        public synchronized E remove catch (InterruptedException e)
            {
            while    throw new RuntimeException(fCurrrentCnt==0"Waiting thread was interrupted during remove with msg:",e);
            {}
        }
         try  
         
        {
E elem =  fQueue.remove();
        fCnt--;
        waitnotifyAll();
        return elem;
    }

    }@Override
    public boolean add(E elem)
    {
       catch if(InterruptedExceptionfCnt e== fSize)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
            }
        }
         
    }
    return fQueue.add(elem);
    }

}

Updated code:

/**
 * Implements a blocking bounded 
 queue from a given non-blocking unbounded queue implementation
 */
abstract class DerivedQueue<E> implements Queue<E>
{
    DerivedQueue(Queue<E> queue, int size)
    {
 E elem =  fQueue.remove();
   if(queue==null | size <0)
        fCurrrentCnt--;{
            notifyAllthrow new RuntimeException("Bad Input");
        }
    return elem;   fQueue = queue;
        }
fMaxSize = size;
    }
    @Override
     
    public 
 synchronized  boolean add(EQueue<E> elem)fQueue;
    int fMaxSize ;
    int {fCurrrentCnt;
     

    @Override
    while(fCurrrentCnt==public fMaxSizeboolean isEmpty()
    {
        {
return (fCurrrentCnt==0);
    }

    public synchronized E remove()
    try{
        while(fCurrrentCnt==0)
        {
            try
        wait();    {
                }wait();
            }
    catch (InterruptedException e)
      catch (InterruptedException e)
        {
    {
                throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
            }
        }
            
  }      
        E elem =  fQueue.remove();
        fCurrrentCnt--;
   boolean bool = fQueue.  notifyAll();
        return elem;
    }

    @Override
    public synchronized  boolean add(E elem);
    {
        notifyAllwhile(fCurrrentCnt== fMaxSize )
        {
            try
            {
                wait();
           return bool;}
            catch (InterruptedException e)
            {
                throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
            }
        }
        
       boolean bool = fQueue.add(elem);
       notifyAll();
       return bool;

    }

}

    /**
     * Implements a blocking bounded queue from a given non-blocking unbounded queue implementation
     */
    abstract class DerivedQueue<E> implements Queue<E>
    {
        DerivedQueue(Queue<E> queue, int size)
        {
            if(queue==null | size <0)
            {
                throw new RuntimeException("Bad Input");
            }
            fQueue = queue;
            fMaxSize = size;
        }
        
        
        
        Queue<E> fQueue;
        int fMaxSize ;
        int fCurrrentCnt;
        
 
        @Override
        public boolean isEmpty()
        {
            return (fCurrrentCnt==0);
        }
 
        public synchronized E remove()
        {
            while(fCurrrentCnt==0)
            {
                try
                {
                    wait();
                }
                catch (InterruptedException e)
                {
                    throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
                }
            }
               
             
            E elem =  fQueue.remove();
            fCurrrentCnt--;
            notifyAll();
            return elem;
        }

        @Override
        public synchronized  boolean add(E elem)
        {
            while(fCurrrentCnt== fMaxSize )
            {
                try
                {
                    wait();
                }
                catch (InterruptedException e)
                {
                    throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
                }
            }
            
           boolean bool = fQueue.add(elem);
           notifyAll();
           return bool;

        }

    }

Original code:

/**
 * Implements a blocking bounded queue from a given non-blocking unbounded queue implementation
 */
abstract class DerivedQueue<E> implements Queue<E>
{
    DerivedQueue(Queue<E> queue, int size)
    {
        if(queue==null | size <0)
        {
            throw new RuntimeException("Bad Input");
        }
        fQueue = queue;
        fSize = size;
    }
     
     
    
    Queue<E> fQueue;
    int fSize;
    int fCnt;
     
    @Override
    public boolean addAll(Collection<? extends E> arg0)
    {
        return false;
    }

    @Override
    public boolean isEmpty()
    {
        return (fCnt==0);
    }

    public E remove()
    {
        if(fCnt==0)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
            }
        }
           
         
        E elem =  fQueue.remove();
        fCnt--;
        notifyAll();
        return elem;
    }

    @Override
    public boolean add(E elem)
    {
        if(fCnt == fSize)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
            }
        }
         
        return fQueue.add(elem);
    }

}

Updated code:

/**
 * Implements a blocking bounded queue from a given non-blocking unbounded queue implementation
 */
abstract class DerivedQueue<E> implements Queue<E>
{
    DerivedQueue(Queue<E> queue, int size)
    {
        if(queue==null | size <0)
        {
            throw new RuntimeException("Bad Input");
        }
        fQueue = queue;
        fMaxSize = size;
    }
    
     
     
    Queue<E> fQueue;
    int fMaxSize ;
    int fCurrrentCnt;
     

    @Override
    public boolean isEmpty()
    {
        return (fCurrrentCnt==0);
    }

    public synchronized E remove()
    {
        while(fCurrrentCnt==0)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
            }
        }
            
        
        E elem =  fQueue.remove();
        fCurrrentCnt--;
        notifyAll();
        return elem;
    }

    @Override
    public synchronized  boolean add(E elem)
    {
        while(fCurrrentCnt== fMaxSize )
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                throw new RuntimeException("Waiting thread was interrupted during remove with msg:",e);
            }
        }
        
       boolean bool = fQueue.add(elem);
       notifyAll();
       return bool;

    }

}

improves formatting

Source Link

edited Oct 28, 2012 at 9:35

palacsint

30.4k
9
82
157

bounded Bounded blocking Queuequeue

Open questions apart from CR:
1] Would calling notifyAll() lead to multiple waiting thread checking the while() condition at the same time .. and hence there is a possibility that before the while gets saitsfied, 2 threads are already out of it causing outOfBound exception ?
OR does the methods need to be marked synchronized at all , instead I can use a synchronized block for reading or writing part of the array while the checking of constrained and waiting can remain unsynchronized ?

2] Is their a way to notify precisely only the consumer threads[waiting in take] or only the producer[waiting input] threads in this example ? . NotifyAll notifies all of them

Thanks!

Would calling notifyAll() lead to multiple waiting thread checking the while() condition at the same time .. and hence there is a possibility that before the while gets saitsfied, 2 threads are already out of it causing outOfBound exception?
OR does the methods need to be marked synchronized at all, instead I can use a synchronized block for reading or writing part of the array while the checking of constrained and waiting can remain unsynchronized?

Is their a way to notify precisely only the consumer threads[waiting in take] or only the producer[waiting input] threads in this example? notifyAll notifies all of them

bounded blocking Queue

Open questions apart from CR:
1] Would calling notifyAll() lead to multiple waiting thread checking the while() condition at the same time .. and hence there is a possibility that before the while gets saitsfied, 2 threads are already out of it causing outOfBound exception ?
OR does the methods need to be marked synchronized at all , instead I can use a synchronized block for reading or writing part of the array while the checking of constrained and waiting can remain unsynchronized ?

2] Is their a way to notify precisely only the consumer threads[waiting in take] or only the producer[waiting input] threads in this example ? . NotifyAll notifies all of them

Thanks!

Bounded blocking queue

Open questions apart from CR:

Would calling notifyAll() lead to multiple waiting thread checking the while() condition at the same time .. and hence there is a possibility that before the while gets saitsfied, 2 threads are already out of it causing outOfBound exception?
OR does the methods need to be marked synchronized at all, instead I can use a synchronized block for reading or writing part of the array while the checking of constrained and waiting can remain unsynchronized?

Is their a way to notify precisely only the consumer threads[waiting in take] or only the producer[waiting input] threads in this example? notifyAll notifies all of them

added 272 characters in body

Source Link

edited Jul 13, 2011 at 2:21

p101

343
1
4
9

Loading

Tweeted twitter.com/#!/StackCodeReview/status/88537329056227328

occurred Jul 6, 2011 at 9:18

added 403 characters in body

Source Link

edited Jul 2, 2011 at 19:37

p101

343
1
4
9

Loading

Added missing notifyAll to add, made methods synchronized , added a while loop for the wait()

Source Link

edited Jul 2, 2011 at 19:27

p101

343
1
4
9

Loading

Change field names based on Fge's comments

Source Link

edited Jun 30, 2011 at 5:38

p101

343
1
4
9

Loading

Source Link

asked Jun 28, 2011 at 6:25

p101

343
1
4
9

Loading

Stack Exchange Network

Return to Question

bounded Bounded blocking Queuequeue

bounded blocking Queue

Bounded blocking queue