Как можно упростить код для обедающих философов и добавить описание действия для каждого философа?

import java.util.Random;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
 
public class Philosopher implements Runnable {
 
    private final Semaphore waiter; // слуга
    private final AtomicInteger eaten; // съедено
    private final long eatTime; // время есть
    private final long thinkTime; // время думать
    private final Fork fork1, fork2; // вилки
    private int count;
    Random rnd = new Random();
 
    public Philosopher(Semaphore waiter, AtomicInteger eaten, long eatTime, long thinkTime, Fork fork1, Fork fork2) {
        this.waiter = waiter;
        this.eaten = eaten;
        this.eatTime = eatTime;
        this.thinkTime = thinkTime;
        this.fork1 = fork1;
        this.fork2 = fork2;
    }
 
    private void take(Fork fork) {
        fork.onTake();
    }
 
    private void put(Fork fork) {
        fork.onPut();
    }
 
    private void eat() {
        count++;
        Util.waitMillis(eatTime);
    }
 
    private void think() {
        Util.waitMillis(thinkTime);
    }
 
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                waiter.acquire();
 
                take(fork1);
                take(fork2);
                eat();
                put(fork1);
                put(fork2);
 
                think();
            } catch (InterruptedException e) {
                // do nothing
            } finally {
                waiter.release();
                think();
            }
        }
        eaten.set(count);
    }
}

import java.util.Arrays;
import java.util.concurrent.atomic.AtomicInteger;
 
public class Util {
 
    public static void printResult(String s, AtomicInteger[] a){
        int sum = 0;
        int[] answer = new int[a.length];
        for (int i = 0; i < answer.length; i++) {
            answer[i] = a[i].get();
            sum += answer[i];
        }
        String[] percentage = new String[answer.length];
        for (int i = 0; i < answer.length; i++) {
            double percents =  10000.0 * answer[i] / sum;
            long round = Math.round(percents);
            percentage[i] = "" + round / 100 + "."
                    + (round % 100 < 10 ? "0" : "") + round % 100 + "%";
        }
 
        System.out.println(s + " " + sum + ": " + Arrays.toString(answer));
        System.out.println("Percentage: " + Arrays.toString(percentage));
        System.out.println();
        waitMillis(1000);
    }
 
    public static void printResult(AtomicInteger[] a){
        printResult("Eaten", a);
    }
 
    public static void waitMillis(long millis) {
        if (millis <= 0) {
            return;
        }
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class Fork {
 
    private final Lock lock = new ReentrantLock();
 
    public void onTake() {
        lock.lock();
    }
 
    public void onPut() {
        lock.unlock();
    }
}

public class Main {
    public static int N = 5;
 
    public static void main(String[] args) throws InterruptedException {
        run(0, 0);
        run(0, 1);
        run(1, 0);
        run(1, 1);
    }
 
    private static void run(long eatTime, long thinkTime) {
        System.out.println("eat= " + eatTime + "ms, think = " + thinkTime + "ms");
        new Waiter(N, eatTime, thinkTime).newRun();
    }
}