Set up a Fiveton class to be accessed by different threads in round-robin fashion

Question

Similar to Singleton class I want to create a Fiveton class which can create maximum 5 instances of the class. Different threads are trying to access instances of this class (hence getInstance method needs to be provided). However class is heavy so the instances must not be eagerly created i.e. created on demand.

Also contract is that threads are allotted instances in round robin fashion i.e. Thread no.1, 6, 11 get instance 1 of Fiveton object. If the instance is being used by a thread, they wait for the lock (it may be possible that thread 6 and 11 wait for instance 1 and thread 11 may get it but in no circumstance thread 11 should get instance 2). Similarly, Thread no. 2, 7, 12 should get instance 2.

Answer 1

Don't code that in your class itself*, instead, use an object pool.

A good library to get you started is Apache Commons / Pool

Another one I don't know but that claims to be faster is furious-objectpool

Use one of the supplied implementations or use the libraries as a basis to build your own custom pool.

* Why not code that into the class itself? Because what a class does and how to get access to instances of a class are unrelated concerns. The class should concentrate on it's core purposes and not about managing itself.

Answer 2

If you care about contention while instances are created (i.e. you don't want Thread 6 to block because Thread 2 is still creating its instance), you can use a lock striping strategy - in this implementation, it is assumed that Thread 1, 2, ... call getInstance one after the other:

class CyclicFiveton {

    private static final CyclicFiveton[] fivetons = new CyclicFiveton[5];
    private static final Object[] locks = new Object[5];
    private static final AtomicInteger counter = new AtomicInteger();

    static {
        for (int i = 0; i < 5; i++) {
            locks[i] = new Object();
        }
    }

    private CyclicFiveton() {
    }

    public static CyclicFiveton getInstance() {
        int index = counter.getAndIncrement() % 5;
        synchronized (locks[index]) {
            CyclicFiveton fiveton = fivetons[index];
            if (fiveton == null) {
                fiveton = new CyclicFiveton();
                fivetons[index] = fiveton;
            }
            return fiveton;
        }
    }
}

Answer 3

If i understood you requirements correctly you can try something like this:

public class Fiveton {

private Fiveton(){
    //create private constructor to prevent new instances from outside of the class
}

private static final int MAX_NB_INSTANCES = 5;
private static List<Fiveton> instances; 

/**
 * Should be called once at the beginning 
 */
public static void init(){
    instances =  new ArrayList<Fiveton>(MAX_NB_INSTANCES);
    for(int i=0;i<MAX_NB_INSTANCES;i++){
        instances.add(new Fiveton());
    }
}

/**
 *  threadNb can be the name of the Thread::getName() 
 * 
 * @param threadNb
 * @return Fiveton
 */
public static Fiveton getInstance(int threadNb){
    synchronized(instances.get(threadNb%MAX_NB_INSTANCES)){
        return instances.get(threadNb%MAX_NB_INSTANCES);
    }       
}  

/**
 * other logic
 * 
 */

}

All you need is to add the logic behind the Fiveton object.

UPDATE

Or as Sean Patrick Floyd well pointed out you can use this just to manage the instances and have a different class (object) for the logic that you want its much cleaner and transparent this way.

UPDATE

Added lazy initialization