Method run

oshi-core/src/test/java/oshi/util/MemoizerTest.java:109–173

(final long iterationDurationNanos, final long ttlNanos)

    }

    private void run(final long iterationDurationNanos, final long ttlNanos) throws Throwable {
        final Supplier<Long> s = new Supplier<Long>() {
            private long value;

            // this method is not thread-safe, the returned value of the counter may go down
            // if this method is called concurrently from different threads
            @Override
            public Long get() {
                return ++value;
            }
        };
        // The memoizer we are testing
        final Supplier<Long> m = memoize(s, ttlNanos);
        // Hold the results until all threads terminate
        final Collection<Future<Void>> results = new ArrayList<>();
        // Mark the start time, end after iterationDuration
        final long beginNanos = System.nanoTime();
        for (int tid = 0; tid < numberOfThreads; tid++) {
            results.add(ex.submit(() -> {
                // First read from the memoizer. Only one thread will win this race to increment
                // 0 to 1, but all threads should read at least 1, if not increment further
                Long previousValue = m.get();
                assertThat("previousValue should not be null", previousValue, is(notNullValue()));
                assertThat("previousValue should be greater than zero", previousValue, is(greaterThan(0L)));
                // Memoizer's ttl was set during previous call (for race winning thread) or
                // earlier (for losing threads) but if we delay for at least ttl from now, we
                // are sure to get at least one increment if ttl is nonnegative
                final long firstSupplierCallNanos = System.nanoTime();
                // using guaranteedIteration this loop is guaranteed to be executed at
                // least once regardless of whether we have exceeded time delays
                boolean guaranteedIteration = false;
                long now;
                while ((now = System.nanoTime()) - beginNanos < iterationDurationNanos
                        || now - firstSupplierCallNanos < ttlNanos || (guaranteedIteration = !guaranteedIteration)) {
                    // guaranteedIteration will only be set true when the first two timing
                    // conditions are false, which will allow at least one iteration. After that
                    // final iteration the boolean will toggle false again to stop the loop.
                    if (Thread.currentThread().isInterrupted()) {
                        throw new InterruptedException();
                    }
                    final Long newValue = m.get();
                    // check that we never get uninitialized
                    assertThat("newValue should not be null", newValue, is(notNullValue()));
                    // check that the counter never goes down // value
                    assertThat("newValue shuld be larger", newValue, is(not(lessThan(previousValue))));
                    previousValue = newValue;
                }
                return null;
            }));
        }
        /*
         * Make sure all the submitted tasks finished correctly
         */
        finishAllThreads(results);
        /*
         * All the writes to s.value field happened-before this read because of all the
         * result.get() invocations, so it holds the final/max value returned by any
         * thread. We cannot access s.value but it's private, and s.get() will increment