Java线程如何基于理论时间单元等待而非使用Thread.sleep()？

我正在完成大学作业，并非寻求核心问题的解决帮助（核心问题已解决），只是当前解决方案比较杂乱，需要优化输出实现。

作业背景 #

任务涉及并发与信号量：存在一个共享资源，最多允许X（X>1）个线程同时访问，算法比单纯的获取/释放访问权更复杂。要求假设到达、访问、释放和离开资源时无时间损耗，通过输出每个线程的到达、访问资源及离开时间，验证算法有效性。

当前实现与问题 #

我用带X个许可的Semaphore管控访问，功能正常，但输出实现粗糙。当前代码大致如下：

@Override
public void run() {
    long alive = System.currentTimeMillis();
    try { Thread.sleep(arrivalTime * 1000); }
    catch (InterruptedException e) {} // no interrupts implemented
    long actualArriveTime = System.currentTimeMillis() - alive;

    boolean accessed = false;
    while (!accessed) accessed = tryAcquire();
    long actualAccessTime = System.currentTimeMillis() - alive;

    try { Thread.sleep(useTime * 1000); }
    catch (InterruptedException e) {} // no interrupts implemented
    release();
    long actualDepartTime = System.currentTimeMillis() - alive;

    System.out.println(actualArriveTime);
    System.out.println(actualAccessTime);
    System.out.println(actualDepartTime);
}

预期输出格式：

Thread  Arrival Access  Departure
A       0       0       3
B       0       0       5
C       2       2       6
...     ...     ...     ...

但实际输出是：

Thread  Arrival Access  Departure
A       0       0       3006
B       0       0       5008
C       2       2       6012
...     ...     ...     ...

我通过放大时间周期（用秒级sleep）来减少操作延迟的影响，之后四舍五入到秒数得到预期结果，但存在两个问题：

• A：运行缓慢；
• B：线程数量过多时，毫秒级延迟累积可能导致四舍五入出错。

期望的实现方式 #

希望用模拟时钟的方式替代真实时间，类似如下伪代码的逻辑：

public static void main(String[] args) {
    int clock = 0;
    while (threadsWaiting) {
        clock++;
    }
}

@Override
public void run() {
    Thread.waitUntil(clock == arrivalTime);

    boolean accessed = false;
    while (!accessed) accessed = tryAcquire();
    int accessTime = clock;

    int departureTime = accessTime + useTime;
    Thread.waitUntil(clock == departureTime);
    release();

    System.out.println(arrivalTime);
    System.out.println(accessTime);
    System.out.println(departureTime);
}

需要实现这种基于模拟时钟的方案，避免真实时间的延迟问题。

内容的提问来源于stack exchange，提问作者goldilocks