java Semaphore

//Listing 6-4. Using a Counting Semaphore to Control Access to a Pool of Items
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Semaphore;

public class A {
    public static void main(String[] args) {
        final Pool pool = new Pool();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                try {
                    while (true) {
                        String item;
                        System.out.println(name + " acquiring "
                                + (item = pool.getItem()));
                        Thread.sleep( + (int) (Math.random() * ));
                        System.out.println(name + " putting back " + item);
                        pool.putItem(item);
                    }
                }

                catch (InterruptedException ie) {
                    System.out.println(name + "interrupted");
                }
            }
        };
        ExecutorService[] executors = new ExecutorService[Pool.MAX_AVAILABLE + ];
        for (int i = ; i < executors.length; i++) {
            executors[i] = Executors.newSingleThreadExecutor();
            executors[i].execute(r);
        }
    }
}

final class Pool {
    public static final int MAX_AVAILABLE = ;
    private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);
    private final String[] items;
    private final boolean[] used = new boolean[MAX_AVAILABLE];

    Pool() {
        items = new String[MAX_AVAILABLE];
        for (int i = ; i < items.length; i++)
            items[i] = "I" + i;
    }

    String getItem() throws InterruptedException {
        available.acquire();
        return getNextAvailableItem();
    }

    void putItem(String item) {
        if (markAsUnused(item))
            available.release();
    }

    private synchronized String getNextAvailableItem() {
        for (int i = ; i < MAX_AVAILABLE; ++i) {
            if (!used[i]) {
                used[i] = true;
                return items[i];
            }
        }
        return null; // not reached
    }

    private synchronized boolean markAsUnused(String item) {
        for (int i = ; i < MAX_AVAILABLE; ++i) {
            if (item == items[i]) {
                if (used[i]) {
                    used[i] = false;
                    return true;
                } else
                    return false;
            }
        }
        return false;
    }
}