diff --git a/src/main/java/org/apache/commons/pool2/PoolUtils.java b/src/main/java/org/apache/commons/pool2/PoolUtils.java
index b07db0d89..b4e614feb 100644
--- a/src/main/java/org/apache/commons/pool2/PoolUtils.java
+++ b/src/main/java/org/apache/commons/pool2/PoolUtils.java
@@ -1370,7 +1370,7 @@ private static final class ErodingFactor {
         private final float factor;
 
         /** Time of next shrink event */
-        private transient volatile long nextShrink;
+        private transient volatile long nextShrinkMillis;
 
         /** High water mark - largest numIdle encountered */
         private transient volatile int idleHighWaterMark;
@@ -1383,7 +1383,7 @@ private static final class ErodingFactor {
          */
         public ErodingFactor(final float factor) {
             this.factor = factor;
-            nextShrink = System.currentTimeMillis() + (long) (900000 * factor); // now
+            nextShrinkMillis = System.currentTimeMillis() + (long) (900000 * factor); // now
                                                                                 // +
                                                                                 // 15
                                                                                 // min
@@ -1395,18 +1395,18 @@ public ErodingFactor(final float factor) {
         /**
          * Updates internal state using the supplied time and numIdle.
          *
-         * @param now
+         * @param nowMillis
          *            current time
          * @param numIdle
          *            number of idle elements in the pool
          */
-        public void update(final long now, final int numIdle) {
+        public void update(final long nowMillis, final int numIdle) {
             final int idle = Math.max(0, numIdle);
             idleHighWaterMark = Math.max(idle, idleHighWaterMark);
             final float maxInterval = 15f;
             final float minutes = maxInterval +
                     ((1f - maxInterval) / idleHighWaterMark) * idle;
-            nextShrink = now + (long) (minutes * 60000f * factor);
+            nextShrinkMillis = nowMillis + (long) (minutes * 60000f * factor);
         }
 
         /**
@@ -1415,7 +1415,7 @@ public void update(final long now, final int numIdle) {
          * @return next shrink time
          */
         public long getNextShrink() {
-            return nextShrink;
+            return nextShrinkMillis;
         }
 
         /**
@@ -1482,16 +1482,16 @@ public T borrowObject() throws Exception, NoSuchElementException,
         @Override
         public void returnObject(final T obj) {
             boolean discard = false;
-            final long now = System.currentTimeMillis();
+            final long nowMillis = System.currentTimeMillis();
             synchronized (pool) {
-                if (factor.getNextShrink() < now) { // XXX: Pool 3: move test
+                if (factor.getNextShrink() < nowMillis) { // XXX: Pool 3: move test
                                                     // out of sync block
                     final int numIdle = pool.getNumIdle();
                     if (numIdle > 0) {
                         discard = true;
                     }
 
-                    factor.update(now, numIdle);
+                    factor.update(nowMillis, numIdle);
                 }
             }
             try {
@@ -1651,16 +1651,16 @@ public V borrowObject(final K key) throws Exception,
         @Override
         public void returnObject(final K key, final V obj) throws Exception {
             boolean discard = false;
-            final long now = System.currentTimeMillis();
+            final long nowMillis = System.currentTimeMillis();
             final ErodingFactor factor = getErodingFactor(key);
             synchronized (keyedPool) {
-                if (factor.getNextShrink() < now) {
+                if (factor.getNextShrink() < nowMillis) {
                     final int numIdle = getNumIdle(key);
                     if (numIdle > 0) {
                         discard = true;
                     }
 
-                    factor.update(now, numIdle);
+                    factor.update(nowMillis, numIdle);
                 }
             }
             try {
diff --git a/src/main/java/org/apache/commons/pool2/impl/DefaultPooledObject.java b/src/main/java/org/apache/commons/pool2/impl/DefaultPooledObject.java
index 57124a11e..f73f0532f 100644
--- a/src/main/java/org/apache/commons/pool2/impl/DefaultPooledObject.java
+++ b/src/main/java/org/apache/commons/pool2/impl/DefaultPooledObject.java
@@ -38,10 +38,10 @@ public class DefaultPooledObject<T> implements PooledObject<T> {
 
     private final T object;
     private PooledObjectState state = PooledObjectState.IDLE; // @GuardedBy("this") to ensure transitions are valid
-    private final long createTime = System.currentTimeMillis();
-    private volatile long lastBorrowTime = createTime;
-    private volatile long lastUseTime = createTime;
-    private volatile long lastReturnTime = createTime;
+    private final long createTimeMillis = System.currentTimeMillis();
+    private volatile long lastBorrowTimeMillis = createTimeMillis;
+    private volatile long lastUseTimeMillis = createTimeMillis;
+    private volatile long lastReturnTimeMillis = createTimeMillis;
     private volatile boolean logAbandoned = false;
     private volatile CallStack borrowedBy = NoOpCallStack.INSTANCE;
     private volatile CallStack usedBy = NoOpCallStack.INSTANCE;
@@ -64,14 +64,14 @@ public T getObject() {
 
     @Override
     public long getCreateTime() {
-        return createTime;
+        return createTimeMillis;
     }
 
     @Override
     public long getActiveTimeMillis() {
         // Take copies to avoid threading issues
-        final long rTime = lastReturnTime;
-        final long bTime = lastBorrowTime;
+        final long rTime = lastReturnTimeMillis;
+        final long bTime = lastBorrowTimeMillis;
 
         if (rTime > bTime) {
             return rTime - bTime;
@@ -81,7 +81,7 @@ public long getActiveTimeMillis() {
 
     @Override
     public long getIdleTimeMillis() {
-        final long elapsed = System.currentTimeMillis() - lastReturnTime;
+        final long elapsed = System.currentTimeMillis() - lastReturnTimeMillis;
         // elapsed may be negative if:
         // - another thread updates lastReturnTime during the calculation window
         // - System.currentTimeMillis() is not monotonic (e.g. system time is set back)
@@ -90,12 +90,12 @@ public long getIdleTimeMillis() {
 
     @Override
     public long getLastBorrowTime() {
-        return lastBorrowTime;
+        return lastBorrowTimeMillis;
     }
 
     @Override
     public long getLastReturnTime() {
-        return lastReturnTime;
+        return lastReturnTimeMillis;
     }
 
     /**
@@ -120,9 +120,9 @@ public long getBorrowedCount() {
     @Override
     public long getLastUsedTime() {
         if (object instanceof TrackedUse) {
-            return Math.max(((TrackedUse) object).getLastUsed(), lastUseTime);
+            return Math.max(((TrackedUse) object).getLastUsed(), lastUseTimeMillis);
         }
-        return lastUseTime;
+        return lastUseTimeMillis;
     }
 
     @Override
@@ -187,8 +187,8 @@ public synchronized boolean endEvictionTest(
     public synchronized boolean allocate() {
         if (state == PooledObjectState.IDLE) {
             state = PooledObjectState.ALLOCATED;
-            lastBorrowTime = System.currentTimeMillis();
-            lastUseTime = lastBorrowTime;
+            lastBorrowTimeMillis = System.currentTimeMillis();
+            lastUseTimeMillis = lastBorrowTimeMillis;
             borrowedCount++;
             if (logAbandoned) {
                 borrowedBy.fillInStackTrace();
@@ -216,7 +216,7 @@ public synchronized boolean deallocate() {
         if (state == PooledObjectState.ALLOCATED ||
                 state == PooledObjectState.RETURNING) {
             state = PooledObjectState.IDLE;
-            lastReturnTime = System.currentTimeMillis();
+            lastReturnTimeMillis = System.currentTimeMillis();
             borrowedBy.clear();
             return true;
         }
@@ -234,7 +234,7 @@ public synchronized void invalidate() {
 
     @Override
     public void use() {
-        lastUseTime = System.currentTimeMillis();
+        lastUseTimeMillis = System.currentTimeMillis();
         usedBy.fillInStackTrace();
     }
 
diff --git a/src/main/java/org/apache/commons/pool2/impl/GenericKeyedObjectPool.java b/src/main/java/org/apache/commons/pool2/impl/GenericKeyedObjectPool.java
index 5dc1a267b..8e65a6110 100644
--- a/src/main/java/org/apache/commons/pool2/impl/GenericKeyedObjectPool.java
+++ b/src/main/java/org/apache/commons/pool2/impl/GenericKeyedObjectPool.java
@@ -337,7 +337,7 @@ public T borrowObject(final K key, final long borrowMaxWaitMillis) throws Except
         final boolean blockWhenExhausted = getBlockWhenExhausted();
 
         boolean create;
-        final long waitTime = System.currentTimeMillis();
+        final long waitTimeMillis = System.currentTimeMillis();
         final ObjectDeque<T> objectDeque = register(key);
 
         try {
@@ -420,7 +420,7 @@ public T borrowObject(final K key, final long borrowMaxWaitMillis) throws Except
             deregister(key);
         }
 
-        updateStatsBorrow(p, System.currentTimeMillis() - waitTime);
+        updateStatsBorrow(p, System.currentTimeMillis() - waitTimeMillis);
 
         return p.getObject();
     }
diff --git a/src/main/java/org/apache/commons/pool2/impl/GenericObjectPool.java b/src/main/java/org/apache/commons/pool2/impl/GenericObjectPool.java
index c1c358ffc..6bb571b93 100644
--- a/src/main/java/org/apache/commons/pool2/impl/GenericObjectPool.java
+++ b/src/main/java/org/apache/commons/pool2/impl/GenericObjectPool.java
@@ -422,7 +422,7 @@ public T borrowObject(final long borrowMaxWaitMillis) throws Exception {
         final boolean blockWhenExhausted = getBlockWhenExhausted();
 
         boolean create;
-        final long waitTime = System.currentTimeMillis();
+        final long waitTimeMillis = System.currentTimeMillis();
 
         while (p == null) {
             create = false;
@@ -500,7 +500,7 @@ public T borrowObject(final long borrowMaxWaitMillis) throws Exception {
             }
         }
 
-        updateStatsBorrow(p, System.currentTimeMillis() - waitTime);
+        updateStatsBorrow(p, System.currentTimeMillis() - waitTimeMillis);
 
         return p.getObject();
     }
@@ -1068,16 +1068,16 @@ private int getNumTests() {
     @SuppressWarnings("resource") // PrintWriter is managed elsewhere
     private void removeAbandoned(final AbandonedConfig abandonedConfig) {
         // Generate a list of abandoned objects to remove
-        final long now = System.currentTimeMillis();
-        final long timeout =
-                now - (abandonedConfig.getRemoveAbandonedTimeout() * 1000L);
+        final long nowMillis = System.currentTimeMillis();
+        final long timeoutMillis =
+                nowMillis - (abandonedConfig.getRemoveAbandonedTimeout() * 1000L);
         final ArrayList<PooledObject<T>> remove = new ArrayList<>();
         final Iterator<PooledObject<T>> it = allObjects.values().iterator();
         while (it.hasNext()) {
             final PooledObject<T> pooledObject = it.next();
             synchronized (pooledObject) {
                 if (pooledObject.getState() == PooledObjectState.ALLOCATED &&
-                        pooledObject.getLastUsedTime() <= timeout) {
+                        pooledObject.getLastUsedTime() <= timeoutMillis) {
                     pooledObject.markAbandoned();
                     remove.add(pooledObject);
                 }
diff --git a/src/main/java/org/apache/commons/pool2/impl/SecurityManagerCallStack.java b/src/main/java/org/apache/commons/pool2/impl/SecurityManagerCallStack.java
index 12a92790d..26936b1e4 100644
--- a/src/main/java/org/apache/commons/pool2/impl/SecurityManagerCallStack.java
+++ b/src/main/java/org/apache/commons/pool2/impl/SecurityManagerCallStack.java
@@ -66,7 +66,7 @@ public boolean printStackTrace(final PrintWriter writer) {
             message = messageFormat;
         } else {
             synchronized (dateFormat) {
-                message = dateFormat.format(Long.valueOf(snapshotRef.timestamp));
+                message = dateFormat.format(Long.valueOf(snapshotRef.timestampMillis));
             }
         }
         writer.println(message);
@@ -109,7 +109,7 @@ private List<WeakReference<Class<?>>> getCallStack() {
      * A snapshot of a class stack.
      */
     private static class Snapshot {
-        private final long timestamp = System.currentTimeMillis();
+        private final long timestampMillis = System.currentTimeMillis();
         private final List<WeakReference<Class<?>>> stack;
 
         /**
diff --git a/src/main/java/org/apache/commons/pool2/impl/ThrowableCallStack.java b/src/main/java/org/apache/commons/pool2/impl/ThrowableCallStack.java
index 3f04e91ff..2ace1b76f 100644
--- a/src/main/java/org/apache/commons/pool2/impl/ThrowableCallStack.java
+++ b/src/main/java/org/apache/commons/pool2/impl/ThrowableCallStack.java
@@ -58,7 +58,7 @@ public synchronized boolean printStackTrace(final PrintWriter writer) {
             message = messageFormat;
         } else {
             synchronized (dateFormat) {
-                message = dateFormat.format(Long.valueOf(snapshotRef.timestamp));
+                message = dateFormat.format(Long.valueOf(snapshotRef.timestampMillis));
             }
         }
         writer.println(message);
@@ -81,6 +81,6 @@ public void clear() {
      */
     private static class Snapshot extends Throwable {
         private static final long serialVersionUID = 1L;
-        private final long timestamp = System.currentTimeMillis();
+        private final long timestampMillis = System.currentTimeMillis();
     }
 }
diff --git a/src/test/java/org/apache/commons/pool2/ObjectPoolIssue326.java b/src/test/java/org/apache/commons/pool2/ObjectPoolIssue326.java
index 7b0341dce..95ed19587 100644
--- a/src/test/java/org/apache/commons/pool2/ObjectPoolIssue326.java
+++ b/src/test/java/org/apache/commons/pool2/ObjectPoolIssue326.java
@@ -74,7 +74,7 @@ private void run() throws Exception {
         // 4 core box.
         // too many doesn't reproduce it ever, too few doesn't either.
         final ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);
-        final long startTime = System.currentTimeMillis();
+        final long startTimeMillis = System.currentTimeMillis();
         long testIter = 0;
         try {
             while (true) {
@@ -89,7 +89,7 @@ private void run() throws Exception {
                 }
             }
         } finally {
-            System.out.println("Time: " + (System.currentTimeMillis() - startTime) / 1000.0);
+            System.out.println("Time: " + (System.currentTimeMillis() - startTimeMillis) / 1000.0);
             service.shutdown();
         }
     }
@@ -147,8 +147,8 @@ public Object call() throws Exception {
 
         private void busyWait(final long timeMillis) {
             // busy waiting intentionally as a simple thread.sleep fails to reproduce
-            final long endTime = System.currentTimeMillis() + timeMillis;
-            while (System.currentTimeMillis() < endTime) {
+            final long endTimeMillis = System.currentTimeMillis() + timeMillis;
+            while (System.currentTimeMillis() < endTimeMillis) {
                 // empty
             }
         }
diff --git a/src/test/java/org/apache/commons/pool2/Waiter.java b/src/test/java/org/apache/commons/pool2/Waiter.java
index e0905efb7..377c144b2 100644
--- a/src/test/java/org/apache/commons/pool2/Waiter.java
+++ b/src/test/java/org/apache/commons/pool2/Waiter.java
@@ -31,8 +31,8 @@ public class Waiter {
     private boolean active = false;
     private boolean valid = true;
     private long latency = 0;
-    private long lastPassivated = 0;
-    private long lastIdleTimeMs = 0;
+    private long lastPassivatedMillis = 0;
+    private long lastIdleTimeMillis = 0;
     private long passivationCount = 0;
     private long validationCount = 0;
     private final int id = instanceCount.getAndIncrement();
@@ -41,7 +41,7 @@ public Waiter(final boolean active, final boolean valid, final long latency) {
         this.active = active;
         this.valid = valid;
         this.latency = latency;
-        this.lastPassivated = System.currentTimeMillis();
+        this.lastPassivatedMillis = System.currentTimeMillis();
     }
 
     /**
@@ -65,8 +65,8 @@ public boolean isActive() {
     }
 
     /**
-     * <p>Sets the active state and updates {@link #getLastIdleTimeMs() lastIdleTime}
-     * or {@link #getLastPassivated() lastPassivated} as appropriate.</p>
+     * <p>Sets the active state and updates {@link #getLastIdleTimeMillis() lastIdleTime}
+     * or {@link #getLastPassivatedMillis() lastPassivated} as appropriate.</p>
      *
      * <p>If the active state is changing from inactive to active, lastIdleTime
      * is updated with the current time minus lastPassivated.  If the state is
@@ -86,11 +86,11 @@ public void setActive(final boolean active) {
             return;
         }
         this.active = active;
-        final long currentTime = System.currentTimeMillis();
+        final long currentTimeMillis = System.currentTimeMillis();
         if (active) {  // activating
-            lastIdleTimeMs = currentTime - lastPassivated;
+            lastIdleTimeMillis = currentTimeMillis - lastPassivatedMillis;
         } else {       // passivating
-            lastPassivated = currentTime;
+            lastPassivatedMillis = currentTimeMillis;
             passivationCount++;
         }
     }
@@ -119,22 +119,22 @@ public void setValid(final boolean valid) {
      *
      * @return time of last passivation
      */
-    public long getLastPassivated() {
-        return lastPassivated;
+    public long getLastPassivatedMillis() {
+        return lastPassivatedMillis;
     }
 
     /**
      * <p>Returns the last idle time for this instance in ms.</p>
      *
      * <p>When an instance is created, and each subsequent time it is passivated,
-     * the {@link #getLastPassivated() lastPassivated} property is updated with the
+     * the {@link #getLastPassivatedMillis() lastPassivated} property is updated with the
      * current time.  When the next activation occurs, {@code lastIdleTime} is
      * updated with the elapsed time since passivation.<p>
      *
      * @return last idle time
      */
-    public long getLastIdleTimeMs() {
-        return lastIdleTimeMs;
+    public long getLastIdleTimeMillis() {
+        return lastIdleTimeMillis;
     }
 
     /**
@@ -170,8 +170,8 @@ public String toString() {
         buff.append("ID = " + id + '\n');
         buff.append("valid = " + valid + '\n');
         buff.append("active = " + active + '\n');
-        buff.append("lastPassivated = " + lastPassivated + '\n');
-        buff.append("lastIdleTimeMs = " + lastIdleTimeMs + '\n');
+        buff.append("lastPassivated = " + lastPassivatedMillis + '\n');
+        buff.append("lastIdleTimeMs = " + lastIdleTimeMillis + '\n');
         buff.append("latency = " + latency + '\n');
         return buff.toString();
     }
diff --git a/src/test/java/org/apache/commons/pool2/impl/TestAbandonedObjectPool.java b/src/test/java/org/apache/commons/pool2/impl/TestAbandonedObjectPool.java
index 64e8282d5..e576a8516 100644
--- a/src/test/java/org/apache/commons/pool2/impl/TestAbandonedObjectPool.java
+++ b/src/test/java/org/apache/commons/pool2/impl/TestAbandonedObjectPool.java
@@ -281,16 +281,15 @@ public void testWhenExhaustedBlock() throws Exception {
         pool.setMaxTotal(1);
 
         @SuppressWarnings("unused") // This is going to be abandoned
-        final
-        PooledTestObject o1 = pool.borrowObject();
+        final PooledTestObject o1 = pool.borrowObject();
 
-        final long start = System.currentTimeMillis();
+        final long startMillis = System.currentTimeMillis();
         final PooledTestObject o2 = pool.borrowObject(5000);
-        final long end = System.currentTimeMillis();
+        final long endMillis = System.currentTimeMillis();
 
         pool.returnObject(o2);
 
-        assertTrue (end - start < 5000);
+        assertTrue(endMillis - startMillis < 5000);
     }
 
     /**
diff --git a/src/test/java/org/apache/commons/pool2/impl/TestDefaultPooledObjectInfo.java b/src/test/java/org/apache/commons/pool2/impl/TestDefaultPooledObjectInfo.java
index fe6113fa1..9a49a6b98 100644
--- a/src/test/java/org/apache/commons/pool2/impl/TestDefaultPooledObjectInfo.java
+++ b/src/test/java/org/apache/commons/pool2/impl/TestDefaultPooledObjectInfo.java
@@ -31,25 +31,25 @@ public class TestDefaultPooledObjectInfo {
     public void testTiming() throws Exception {
         try (final GenericObjectPool<String> pool = new GenericObjectPool<>(new SimpleFactory())) {
 
-            final long t1 = System.currentTimeMillis();
+            final long t1Millis = System.currentTimeMillis();
 
             Thread.sleep(50);
             final String s1 = pool.borrowObject();
             Thread.sleep(50);
 
-            final long t2 = System.currentTimeMillis();
+            final long t2Millis = System.currentTimeMillis();
 
             Thread.sleep(50);
             pool.returnObject(s1);
             Thread.sleep(50);
 
-            final long t3 = System.currentTimeMillis();
+            final long t3Millis = System.currentTimeMillis();
 
             Thread.sleep(50);
             pool.borrowObject();
             Thread.sleep(50);
 
-            final long t4 = System.currentTimeMillis();
+            final long t4Millis = System.currentTimeMillis();
 
             final Set<DefaultPooledObjectInfo> strings = pool.listAllObjects();
 
@@ -59,19 +59,19 @@ public void testTiming() throws Exception {
 
             final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z");
 
-            assertTrue(s1Info.getCreateTime() > t1);
+            assertTrue(s1Info.getCreateTime() > t1Millis);
             assertEquals(sdf.format(Long.valueOf(s1Info.getCreateTime())), s1Info.getCreateTimeFormatted());
-            assertTrue(s1Info.getCreateTime() < t2);
+            assertTrue(s1Info.getCreateTime() < t2Millis);
 
-            assertTrue(s1Info.getLastReturnTime() > t2);
+            assertTrue(s1Info.getLastReturnTime() > t2Millis);
             assertEquals(sdf.format(Long.valueOf(s1Info.getLastReturnTime())),
                     s1Info.getLastReturnTimeFormatted());
-            assertTrue(s1Info.getLastReturnTime() < t3);
+            assertTrue(s1Info.getLastReturnTime() < t3Millis);
 
-            assertTrue(s1Info.getLastBorrowTime() > t3);
+            assertTrue(s1Info.getLastBorrowTime() > t3Millis);
             assertEquals(sdf.format(Long.valueOf(s1Info.getLastBorrowTime())),
                     s1Info.getLastBorrowTimeFormatted());
-            assertTrue(s1Info.getLastBorrowTime() < t4);
+            assertTrue(s1Info.getLastBorrowTime() < t4Millis);
         }
     }
 
diff --git a/src/test/java/org/apache/commons/pool2/impl/TestGenericKeyedObjectPool.java b/src/test/java/org/apache/commons/pool2/impl/TestGenericKeyedObjectPool.java
index 71d7e798c..c6141f77e 100644
--- a/src/test/java/org/apache/commons/pool2/impl/TestGenericKeyedObjectPool.java
+++ b/src/test/java/org/apache/commons/pool2/impl/TestGenericKeyedObjectPool.java
@@ -1314,7 +1314,7 @@ public void testBlockedKeyDoesNotBlockPool() throws Exception {
         gkoPool.setMaxTotalPerKey(1);
         gkoPool.setMaxTotal(-1);
         gkoPool.borrowObject("one");
-        final long start = System.currentTimeMillis();
+        final long startMillis = System.currentTimeMillis();
         // Needs to be in a separate thread as this will block
         final Runnable simple = new SimpleTestThread<>(gkoPool, "one");
         (new Thread(simple)).start();
@@ -1323,12 +1323,13 @@ public void testBlockedKeyDoesNotBlockPool() throws Exception {
         // Give other thread a chance to start
         Thread.sleep(1000);
         gkoPool.borrowObject("two");
-        final long end = System.currentTimeMillis();
+        final long endMillis = System.currentTimeMillis();
         // If it fails it will be more than 4000ms (5000 less the 1000 sleep)
         // If it passes it should be almost instant
         // Use 3000ms as the threshold - should avoid timing issues on most
         // (all? platforms)
-        assertTrue ((end-start) < 4000,"Elapsed time: "+(end-start)+" should be less than 4000");
+        assertTrue((endMillis - startMillis) < 4000,
+                "Elapsed time: " + (endMillis - startMillis) + " should be less than 4000");
 
     }
 
@@ -1361,7 +1362,7 @@ public void testMaxWaitMultiThreaded() throws Exception {
         for(int i=0; i < wtt.length; i++){
             wtt[i] = new WaitingTestThread(gkoPool,Integer.toString(i % keyCount),holdTime);
         }
-        final long origin = System.currentTimeMillis()-1000;
+        final long originMillis = System.currentTimeMillis() - 1000;
         for (final WaitingTestThread element : wtt) {
             element.start();
         }
@@ -1383,11 +1384,11 @@ public void testMaxWaitMultiThreaded() throws Exception {
                     );
             for (final WaitingTestThread wt : wtt) {
                 System.out.println(
-                        "Preborrow: " + (wt.preborrow-origin) +
-                        " Postborrow: " + (wt.postborrow != 0 ? wt.postborrow-origin : -1) +
-                        " BorrowTime: " + (wt.postborrow != 0 ? wt.postborrow-wt.preborrow : -1) +
-                        " PostReturn: " + (wt.postreturn != 0 ? wt.postreturn-origin : -1) +
-                        " Ended: " + (wt.ended-origin) +
+                        "Preborrow: " + (wt.preBorrowMillis - originMillis) +
+                        " Postborrow: " + (wt.postBorrowMillis != 0 ? wt.postBorrowMillis - originMillis : -1) +
+                        " BorrowTime: " + (wt.postBorrowMillis != 0 ? wt.postBorrowMillis - wt.preBorrowMillis : -1) +
+                        " PostReturn: " + (wt.postReturnMillis != 0 ? wt.postReturnMillis - originMillis : -1) +
+                        " Ended: " + (wt.endedMillis - originMillis) +
                         " Key: " + (wt._key) +
                         " ObjId: " + wt.objectId
                         );
@@ -1713,10 +1714,10 @@ static class WaitingTestThread extends Thread {
         private final long _pause;
         private Throwable _thrown;
 
-        private long preborrow; // just before borrow
-        private long postborrow; //  borrow returned
-        private long postreturn; // after object was returned
-        private long ended;
+        private long preBorrowMillis; // just before borrow
+        private long postBorrowMillis; //  borrow returned
+        private long postReturnMillis; // after object was returned
+        private long endedMillis;
         private String objectId;
 
         public WaitingTestThread(final KeyedObjectPool<String,String> pool, final String key, final long pause) {
@@ -1729,17 +1730,17 @@ public WaitingTestThread(final KeyedObjectPool<String,String> pool, final String
         @Override
         public void run() {
             try {
-                preborrow = System.currentTimeMillis();
+                preBorrowMillis = System.currentTimeMillis();
                 final String obj = _pool.borrowObject(_key);
                 objectId = obj;
-                postborrow = System.currentTimeMillis();
+                postBorrowMillis = System.currentTimeMillis();
                 Thread.sleep(_pause);
                 _pool.returnObject(_key, obj);
-                postreturn = System.currentTimeMillis();
+                postReturnMillis = System.currentTimeMillis();
             } catch (final Exception e) {
                 _thrown = e;
             } finally{
-                ended = System.currentTimeMillis();
+                endedMillis = System.currentTimeMillis();
             }
         }
     }
diff --git a/src/test/java/org/apache/commons/pool2/impl/TestGenericObjectPool.java b/src/test/java/org/apache/commons/pool2/impl/TestGenericObjectPool.java
index 233367519..8381631f5 100644
--- a/src/test/java/org/apache/commons/pool2/impl/TestGenericObjectPool.java
+++ b/src/test/java/org/apache/commons/pool2/impl/TestGenericObjectPool.java
@@ -553,10 +553,10 @@ static class WaitingTestThread extends Thread {
         private final long _pause;
         private Throwable _thrown;
 
-        private long preborrow; // just before borrow
-        private long postborrow; //  borrow returned
-        private long postreturn; // after object was returned
-        private long ended;
+        private long preBorrowMillis; // just before borrow
+        private long postBorrowMillis; //  borrow returned
+        private long postReturnMillis; // after object was returned
+        private long endedMillis;
         private String objectId;
 
         public WaitingTestThread(final GenericObjectPool<String> pool, final long pause) {
@@ -568,17 +568,17 @@ public WaitingTestThread(final GenericObjectPool<String> pool, final long pause)
         @Override
         public void run() {
             try {
-                preborrow = System.currentTimeMillis();
+                preBorrowMillis = System.currentTimeMillis();
                 final String obj = _pool.borrowObject();
                 objectId = obj;
-                postborrow = System.currentTimeMillis();
+                postBorrowMillis = System.currentTimeMillis();
                 Thread.sleep(_pause);
                 _pool.returnObject(obj);
-                postreturn = System.currentTimeMillis();
+                postReturnMillis = System.currentTimeMillis();
             } catch (final Throwable e) {
                 _thrown = e;
             } finally{
-                ended = System.currentTimeMillis();
+                endedMillis = System.currentTimeMillis();
             }
         }
     }
@@ -1551,10 +1551,10 @@ public void testEvictionPolicy() throws Exception {
     @Timeout(value = 60000, unit = TimeUnit.MILLISECONDS)
     public void testEvictionSoftMinIdle() throws Exception {
         class TimeTest extends BasePooledObjectFactory<TimeTest> {
-            private final long createTime;
+            private final long createTimeMillis;
 
             public TimeTest() {
-                createTime = System.currentTimeMillis();
+                createTimeMillis = System.currentTimeMillis();
             }
 
             @Override
@@ -1562,8 +1562,8 @@ public TimeTest create() throws Exception {
                 return new TimeTest();
             }
 
-            public long getCreateTime() {
-                return createTime;
+            public long getCreateTimeMillis() {
+                return createTimeMillis;
             }
 
             @Override
@@ -1585,7 +1585,7 @@ public PooledObject<TimeTest> wrap(final TimeTest value) {
             final Long[] creationTime = new Long[5];
             for (int i = 0; i < 5; i++) {
                 active[i] = timePool.borrowObject();
-                creationTime[i] = Long.valueOf((active[i]).getCreateTime());
+                creationTime[i] = Long.valueOf((active[i]).getCreateTimeMillis());
             }
 
             for (int i = 0; i < 5; i++) {
@@ -2239,7 +2239,7 @@ public void testMaxWaitMultiThreaded() throws Exception {
         for (int i = 0; i < wtt.length; i++) {
             wtt[i] = new WaitingTestThread(genericObjectPool,holdTime);
         }
-        final long origin = System.currentTimeMillis() - 1000;
+        final long originMillis = System.currentTimeMillis() - 1000;
         for (final WaitingTestThread element : wtt) {
             element.start();
         }
@@ -2260,11 +2260,11 @@ public void testMaxWaitMultiThreaded() throws Exception {
                     );
             for (final WaitingTestThread wt : wtt) {
                 System.out.println(
-                        "PreBorrow: " + (wt.preborrow - origin) +
-                        " PostBorrow: " + (wt.postborrow != 0 ? wt.postborrow - origin : -1) +
-                        " BorrowTime: " + (wt.postborrow != 0 ? wt.postborrow - wt.preborrow : -1) +
-                        " PostReturn: " + (wt.postreturn != 0 ? wt.postreturn - origin : -1) +
-                        " Ended: " + (wt.ended - origin) +
+                        "PreBorrow: " + (wt.preBorrowMillis - originMillis) +
+                        " PostBorrow: " + (wt.postBorrowMillis != 0 ? wt.postBorrowMillis - originMillis : -1) +
+                        " BorrowTime: " + (wt.postBorrowMillis != 0 ? wt.postBorrowMillis - wt.preBorrowMillis : -1) +
+                        " PostReturn: " + (wt.postReturnMillis != 0 ? wt.postReturnMillis - originMillis : -1) +
+                        " Ended: " + (wt.endedMillis - originMillis) +
                         " ObjId: " + wt.objectId
                         );
             }
diff --git a/src/test/java/org/apache/commons/pool2/performance/PerformanceTest.java b/src/test/java/org/apache/commons/pool2/performance/PerformanceTest.java
index 31a04dfae..6cb9d2254 100644
--- a/src/test/java/org/apache/commons/pool2/performance/PerformanceTest.java
+++ b/src/test/java/org/apache/commons/pool2/performance/PerformanceTest.java
@@ -51,8 +51,8 @@ private static class TaskStats {
 
     class PerfTask implements Callable<TaskStats> {
         final TaskStats taskStats = new TaskStats();
-        long borrowTime;
-        long returnTime;
+        long borrowTimeMillis;
+        long returnTimeMillis;
 
         public void runOnce() {
             try {
@@ -63,9 +63,9 @@ public void runOnce() {
                             "   waiting: " + taskStats.waiting +
                             "   complete: " + taskStats.complete);
                 }
-                final long bbegin = System.currentTimeMillis();
+                final long bbeginMillis = System.currentTimeMillis();
                 final Integer o = pool.borrowObject();
-                final long bend = System.currentTimeMillis();
+                final long bendMillis = System.currentTimeMillis();
                 taskStats.waiting--;
 
                 if (logLevel >= 3) {
@@ -75,13 +75,13 @@ public void runOnce() {
                             "   complete: " + taskStats.complete);
                 }
 
-                final long rbegin = System.currentTimeMillis();
+                final long rbeginMillis = System.currentTimeMillis();
                 pool.returnObject(o);
-                final long rend = System.currentTimeMillis();
+                final long rendMillis = System.currentTimeMillis();
                 Thread.yield();
                 taskStats.complete++;
-                borrowTime = bend - bbegin;
-                returnTime = rend - rbegin;
+                borrowTimeMillis = bendMillis - bbeginMillis;
+                returnTimeMillis = rendMillis - rbeginMillis;
             } catch (final Exception e) {
                 e.printStackTrace();
             }
@@ -92,14 +92,14 @@ public TaskStats call() throws Exception {
            runOnce(); // warmup
            for (int i = 0; i < nrIterations; i++) {
                runOnce();
-               taskStats.totalBorrowTime += borrowTime;
-               taskStats.totalReturnTime += returnTime;
+               taskStats.totalBorrowTime += borrowTimeMillis;
+               taskStats.totalReturnTime += returnTimeMillis;
                taskStats.nrSamples++;
                if (logLevel >= 2) {
                    final String name = "thread" + Thread.currentThread().getName();
                    System.out.println("result " + taskStats.nrSamples + '\t' +
-                           name + '\t' + "borrow time: " + borrowTime + '\t' +
-                           "return time: " + returnTime + '\t' + "waiting: " +
+                           name + '\t' + "borrow time: " + borrowTimeMillis + '\t' +
+                           "return time: " + returnTimeMillis + '\t' + "waiting: " +
                            taskStats.waiting + '\t' + "complete: " +
                            taskStats.complete);
                }