Java Cyclic Barrier

package examples;

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.Callable;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CyclicBarrierExample {

    public static void main(String[] args) {
        Integer minDrinkers = 4;
        AlcoholicBarOpen barOpen = new AlcoholicBarOpen();
        Party party = new Party(minDrinkers,barOpen);
        CyclicBarrier partyBarrier = party.getBarrier();

        // drinkers can go to the bar and their execution will start
        ExecutorService bar = Executors.newCachedThreadPool();

        // create the drinkers which are callables
        Drinker d1 = new Drinker("Jane","Everclear",partyBarrier);
        Drinker d2 = new Drinker("John","Pabst Blue Ribbon",partyBarrier);
        Drinker d3 = new Drinker("Anup","Blue Moon",partyBarrier);
        Drinker d4 = new Drinker("Vish","Fireball",partyBarrier);
        Drinker d5 = new Drinker("Lisa","Wild Turkey",partyBarrier);
        Drinker d6 = new Drinker("Mark","Laphroaig",partyBarrier);

        // a list of future drinkers who's execution will start asynchronously
        List<Future<DrinkerStatus>> futureDrinkers = new LinkedList<Future<DrinkerStatus>>();

        // convert callable drinkers into future drinkers
        futureDrinkers.add(bar.submit(d1));
        futureDrinkers.add(bar.submit(d2));
        futureDrinkers.add(bar.submit(d3));
        futureDrinkers.add(bar.submit(d4));
        futureDrinkers.add(bar.submit(d5));
        futureDrinkers.add(bar.submit(d6));

        // loop through the drinkers and wait for them to all be done
        for(Future<DrinkerStatus> futureDrinkerStatus: futureDrinkers) {
            try {
                System.out.println(futureDrinkerStatus.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }

        try {
            boolean drinkersLeft = bar.awaitTermination(100, TimeUnit.MILLISECONDS);
            if(drinkersLeft == false) {
                System.err.println("We closed the bar with drinkers waiting");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

// the class that will house the cyclic barrier
class Party {
    private CyclicBarrier barrier;
    public Party(int numPeople, Runnable partyStarted) {
        this.barrier = new CyclicBarrier(numPeople, partyStarted);
    }

    public CyclicBarrier getBarrier() {
        return barrier;
    }
}

// we will print a message when the bar opens
class AlcoholicBarOpen implements Runnable {
    @Override
    public void run() {
        System.out.println("Yay!! The bar is open.");
    }
}

// The Drinker callable that waits on the barrier for a drink or walks away
class Drinker implements Callable<DrinkerStatus> {
    private String name;
    private String drink;
    private CyclicBarrier barrier;

    public Drinker(String name, String drink, CyclicBarrier barrier) {
        this.name = name;
        this.drink = drink;
        this.barrier = barrier;
    }

    @Override
    public DrinkerStatus call() throws Exception {
        System.out.println(name + " is waiting at the bar door for a "+drink+" with "+this.barrier.getNumberWaiting()+" others");
        try {
            this.barrier.await(50, TimeUnit.MILLISECONDS);
            System.out.println(name + " can order a "+drink);
        } catch (InterruptedException | BrokenBarrierException e) {
            System.err.println(name+" abnormally left the party because of interruption, failure, or timeout. Barrier is broken.");
            return new DrinkerStatus(name,"walking away from the bar");
        } catch(TimeoutException e) {
            System.err.println(name + " waited too long and is going elsewhere for a drink. Others that are waiting are leaving");
            return new DrinkerStatus(name,"walking away from the bar");
        }
        return new DrinkerStatus(name,"drinking");
    }
}

// The result of the Drinker Callable where they can either be drinking or walking away
class DrinkerStatus {
    String name;
    String status;

    public DrinkerStatus(String name, String status) {
        super();
        this.name = name;
        this.status = status;
    }

    @Override
    public String toString() {
        return name + " is " + status;
    }
}