public class StaticListContainer {
    private static StaticListContainer self;
    private static int[] list;
    private static volatile int pos;
 
    /*
     * Private constructor that creates a list of 10000 integers.
     */
    private StaticListContainer() {
        list = new int[10000];
 
        for(int i = 0; i < 10000; i++) {
            list[i] = i;
        }
 
        /*
         * Since the array is 0-indexed we need to subtract 1 from the array.length data member.
         */
        pos = list.length - 1;
    }
 
    /*
     * Returns an instance of the StaticListContainer. If the StaticListContainer
     * has not yet been initialized then this method initializes it.
     */
    public static StaticListContainer getInstance() {
        if(self == null) {
            self = new StaticListContainer();
        }
 
        return self;
    }
 
    /*
     * Returns the current integer and decrements the current position by 1.
     */
    public synchronized int pop() {
        int ret = list[pos];
 
        pos -= 1;
 
        return ret;
    }
 
    /*
     * Returns true if the current position is below 0, signifying the list is empty,
     * otherwise returns false.
     */
    public synchronized boolean isEmpty() {
        return pos < 0;
    }
}

public class IntEater extends Thread implements Runnable {
    private String threadName = "";
    private int fullness = 0;
 
    public IntEater(String threadName) {
        this.threadName = threadName;
    }
 
    @Override
    public void run() {
        do {
            // Pop the next integer and eat it
            this.eatInt(StaticListContainer.getInstance().pop());
            fullness++;
        } while (!StaticListContainer.getInstance().isEmpty());
 
        // Once all the numbers have been eaten -- display how full each thread is
        double fullperc = (fullness / 2500.0) * 100.0;
        System.out.println(threadName + " is " + fullperc + "% full after eating " + fullness + " ints.");
    }
 
    private void eatInt(int x) {
        System.out.println(threadName + " is eating " + x);
    }
}

public class ThreadPool {
    private static ThreadPool self;
    private static java.util.ArrayList
 threads;
    private int current;
 
    /*
     * Private constructor initializes the threads list.
     */
    private ThreadPool() {
        threads = new java.util.ArrayList
();
    }
 
    /*
     * Singleton getInstance() method.
     */
    public static ThreadPool getInstance() {
        if(self == null) {
            self = new ThreadPool();
        }
 
        return self;
    }
 
    /*
     * Tell the ThreadPool that the next thread may use the processor now.
     */
    public void next() {
        if(current == threads.size() - 1) {
            current = 0;
        } else {
            current += 1;
        }
    }
 
    /*
     * Add a thread to the pool.
     */
    public void addThread(Thread thread) {
        threads.add(thread);
    }
 
    /*
     * Start all the threads in this pool.
     */
    public void startThreads() {
        for(Thread t: threads) {
            t.start();
        }
    }
 
    /*
     * Force a thread to yield if it is not their turn to use the processor.
     */
    boolean yielding(Thread t) {
        boolean ret = false;
 
        if(threads.indexOf(t) != current) {
            t.yield();
            ret = true;
        }
 
        return ret;
    }
}

...
public void run() {
        do {
            // If the current thread is not supposed to be yielding then do the work
            if(!ThreadPool.getInstance().yielding(this)) {
                //Pop the next integer and eat it
                this.eatInt(StaticListContainer.getInstance().pop());
                fullness++;
 
                /* Must call this method to tell the ThreadPool that it is the next
                 * threads turn to do it's work.
                 */
                ThreadPool.getInstance().next();
            }
        } while (!StaticListContainer.getInstance().isEmpty());
...

public class Main {
    public static void main(String[] args) {
        StaticListContainer.getInstance();
 
        ThreadPool.getInstance();
        ThreadPool.getInstance().addThread(new IntEater("Charlie"));
        ThreadPool.getInstance().addThread(new IntEater("Catehrine"));
        ThreadPool.getInstance().addThread(new IntEater("Oswald"));
        ThreadPool.getInstance().addThread(new IntEater("Bingo"));
        ThreadPool.getInstance().startThreads();
    }
}