Java Blocking List Implementation

Question

I searched for an answer to this question on SO and Google but couldn't find a proper solution so far.

I'm currently working on a LayerManager in a graph routing problem. The manager is responsible for providing and resetting a fixed set of layers.

I wanted to implement the Consumer-Producer pattern with a blocking list, so that incoming routing requests are blocked as long no free layer is available. So far I only found a blocking queue but since we don't need FIFO, LIFO but random access a queue doesn't really work. To be a little more precise, something like this should be possible:

/* this should be blocking until a layer becomes available */
public Layer getLayer(){ 

    for ( Layer layer : layers ) {
        if ( layer.isUnused() && layer.matches(request) )
            return layers.pop(layer);
    }
}

Is there any way to achieve this?

What about java.util.concurrent.PriorityBlockingQueue with your own Comparator? — StanislavL, Apr 27 '15 at 07:37
Thanks. Well, layer are not really comparable in my opinion. they only match to a given request. — Daniel Gerber, Apr 27 '15 at 09:01
@Daniel, I know this is an old question, but what solution have you implemented to solve this problem ? — Guillaume, Jun 13 '19 at 15:13

score 0 · Answer 1 · answered Apr 27 '15 at 08:28

What you are looking for is called "Semaphore".

Create a Semaphore class
Add it as a field to Layer class

Example

 public class Semaphore 
{
    private boolean signal = false;

    public synchronized boolean take() 
    {
       if(this.signal==true)
            return false;  //already in use
       this.signal = true;
       this.notify();
       return true;
    }

     public synchronized void release() throws InterruptedException
     {
        while(!this.signal) wait();
        this.signal = false;
     }


     public boolean isUnused()
     {
         return !signal ;
     }

}


//2.
class Layer
{
    Semaphore sem =null;

    /*your code*/
     /*sem = new Semaphore(); in constructors*/
    public boolean take()
    {
        return this.sem.take();
    }

    public void release()
    {
        this.sem.release();
    }

    public Layer getLayer()
    { 

        for ( Layer layer : layers ) 
        {
         if ( layer.matches(request) && layer.take())
             return layer;
        }

         return null;
    }
}

Synchronized methods handle access concurrence

3. Loop over getLayer until

Layer l=null;
while(l==null)
{
    l= getlayer();
    Thread.sleep(100); //set time
}
 // continue
 // do not forget to release the layer when you are done

that is kind of what I do now, i dont like this notify/wait pattern. it's much more error prone than blocking — Daniel Gerber, Apr 27 '15 at 08:47

alex · Answer 2 · 2015-04-27T09:36:37.887

0

Try to use Map<String, BlockingQueue<Layer>>. The idea is to hold free Layers inside of BlockingQueue. Every request has his own queue.

public class LayerQueue {

    Map<String, BlockingQueue<Layer>> freeLayers = Collections.synchronizedMap(new HashMap<String, BlockingQueue<Layer>>());

    public LayerQueue() {
        //init QUEUEs
        freeLayers.put("request-1", new ArrayBlockingQueue<Layer>(1)); // one to one...
        freeLayers.put("request-2", new ArrayBlockingQueue<Layer>(1));
        [...] 
    }

    public void addUnusedLayer(Layer layer, String request) {
        BlockingQueue<Layer> freeLayersForRequest = freeLayers.get(request);
        freeLayersForRequest.add(layer);
    }

    public Layer getLayer(String request) {

        BlockingQueue<Layer> freeLayersForRequest = freeLayers.get(request);

        try {
            return freeLayersForRequest.take(); // blocks until a layer becomes available
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

edited Apr 27 '15 at 09:36

answered Apr 27 '15 at 08:37

alex

8,904
6
49
75

1 have one layer per request, also the map is not fixed sized – Daniel Gerber Apr 27 '15 at 09:04
@DanielGerber why exactly it should be a problem? – alex Apr 27 '15 at 09:35
Because 1 layer might need up to 500mb of RAM. – Daniel Gerber Apr 27 '15 at 11:30
@DanielGerber Even if it need 4GB it would still work. You are working with references. – alex Apr 27 '15 at 12:20

score 0 · Answer 3 · answered Apr 27 '15 at 09:39

I am not quite sure I understand your need correctly, but you could consume a blocking queue and put the results into a list. If an appropriate layer is not found in the list, call wait() and check again when a new item is added to the list from the queue. This sounds like it could work conceptually, even if the code below doesn't get it right (I am quite sure this is not quite properly synchronized)

public class PredicateBlockingQueue<Product> {

private final List<Product> products = new LinkedList<Product>();
private final BlockingQueue<Product> queue;
private final Thread consumer;

public PredicateBlockingQueue(int capacity) {
    queue = new ArrayBlockingQueue<Product>(capacity);

    consumer = new Thread() {
        @Override
        public void run() {
            while(!Thread.interrupted()) {
                try {
                    products.add(queue.take());
                    synchronized(queue) {
                        queue.notifyAll();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };

    consumer.start();
}

public void put(Product product) throws InterruptedException {
    queue.put(product);
}

public Product take(Predicate<Product> predicate) throws InterruptedException {
    Product product;
    while((product=find(predicate))==null) {
        synchronized(queue) {
            queue.wait();
        }
    }
    return product;
}

private synchronized Product find(Predicate<Product> predicate) {
    Iterator<Product> it = products.iterator();
    while(it.hasNext()) {
        Product product = it.next();
        if(predicate.test(product)) {
            it.remove();
            return product;
        }
    }
    return null;
}

Java Blocking List Implementation

3 Answers3

Linked