Dining Philosophers problem

Resolution.java

import java.util.concurrent.Semaphore;

public class Resolution {

    private static final int EAT_TIME = 3 * 1000;
    private static final int THINK_TIME = 2 * 1000;
    private static final int WAIT_TIME = 1 * 1000;
    private static final int ITERATIONS_NUMBER = 1000;

    private final Semaphore[] semaphores;
    private final Philosophe[] philosophes;

    public Resolution(final int forks) {

        semaphores = new Semaphore[forks];
        philosophes = new Philosophe[forks];
        for (int index = 0; index < forks; index++) {
            semaphores[index] = new Semaphore(1);
            philosophes[index] = new Philosophe(index);
            philosophes[index].start();
        }

    }
    private int getLeftFork(int philosopheIndex) {
        return philosopheIndex == 0 ? philosophes.length - 1 : philosopheIndex - 1;        
    }

    private void waitForForks(int philosopheIndex) {
        semaphores[getLeftFork(philosopheIndex)].acquireUninterruptibly();
        semaphores[philosopheIndex].acquireUninterruptibly();        
    }

    private void releaseForks(final int philosopheIndex) {
        semaphores[getLeftFork(philosopheIndex)].release();
        semaphores[philosopheIndex].release();      
    }

    private void hungry(final int philosophe) {

        final Philosophe current = philosophes[philosophe];
        current.state = PhilosopheState.WAITING;
        System.out.printf("Philosophe: %s is hungry ...\n", current.getName());
        safeSleep(WAIT_TIME);

    }
    private void eat(final int philosophe)  {

        final Philosophe current = philosophes[philosophe];
        waitForForks(philosophe);
        current.state = PhilosopheState.EATING;
        current.eatTimes++;
        System.out.printf("Philosophe: %s is eating ...\t Already ate %d times.\n", current.getName(), current.eatTimes);
        safeSleep(EAT_TIME);
        releaseForks(philosophe);

    }

    private void think(final int philosophe) {

        final Philosophe current = philosophes[philosophe];
        current.state = PhilosopheState.THINKING;
        System.out.printf("Philosophe: %s is thinking ...\n", current.getName());
        safeSleep(THINK_TIME);

    }

    enum PhilosopheState {
        EATING, WAITING, THINKING
    }

    private void safeSleep(int time) {

        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    class Philosophe extends Thread {

        private PhilosopheState state;
        private final int id;
        private int eatTimes;

        public Philosophe(final int id) {
            this.id = id;
            eatTimes = 0;
        }

        @Override
        public void run() {
       
            for (int index = 0; index < ITERATIONS_NUMBER; index++) {
                think(id);
                hungry(id);
                eat(id);
            }
            System.out.printf("Philosophe: %s is done ...\n", getName());
       
        }

    }
    public static void main(String[] args) {
        final int philosophersNumber = 5;    
        final Resolution resolution = new Resolution(philosophersNumber);
    }
}