correctness: Add capacity and eviction bounds check to FrameCache

src/main/java/org/opensourcephysics/cabrillo/tracker/video/FrameCache.java

@@ -27,13 +27,13 @@
     private final Map<Integer, BufferedImage> cache;
 
     /** Lock for thread-safe access to cache state */
     private final ReentrantReadWriteLock lock;
 
     /** Total frames loaded across all cache accesses */
-    private long totalLoads;
+    private final java.util.concurrent.atomic.LongAdder totalLoads;
 
     /** Total frame cache hits */
-    private long totalHits;
+    private final java.util.concurrent.atomic.LongAdder totalHits;
 
     /**
      * Creates a FrameCache with default maximum capacity of 100 frames.
@@ -63,8 +63,8 @@
             }
         };
         this.lock = new ReentrantReadWriteLock();
-        this.totalLoads = 0;
-        this.totalHits = 0;
+        this.totalLoads = new java.util.concurrent.atomic.LongAdder();
+        this.totalHits = new java.util.concurrent.atomic.LongAdder();
     }
 
     /**
@@ -74,26 +74,26 @@
      * This method does not load a new frame - call loadFrame() for that.</p>
      *
      * @param frameIndex the frame index to retrieve
-     * @return the cached Bufferedlmage, or null if not found or index is invalid
+     * @return the cached BufferedImage, or null if not found
      * @throws IllegalStateException if frameIndex is invalid
      */
     public BufferedImage get(int frameIndex) {
         if (frameIndex < 0) {
             throw new IllegalStateException("frameIndex cannot be negative: " + frameIndex);
         }
 
-        lock.writeLock().lock();
+        lock.readLock().lock();
         try {
             BufferedImage frame = cache.get(frameIndex);
             if (frame != null) {
-                totalHits++;
+                totalHits.increment();
             }
             return frame;
         } finally {
-            lock.writeLock().unlock();
+            lock.readLock().unlock();
         }
     }
 
     /**
      * Loads and stores a frame in the cache.
      *
@@ -109,19 +109,18 @@
             throw new IllegalArgumentException("frameIndex cannot be negative: " + frameIndex);
         }
         if (frame == null) {
             throw new IllegalArgumentException("frame cannot be null");
         }
 
-        totalLoads++;
-
         lock.writeLock().lock();
         try {
             // Only update if not already present (hit means no load needed)
             if (!cache.containsKey(frameIndex)) {
+                totalLoads.increment();
                 cache.put(frameIndex, frame);
             }
         } finally {
             lock.writeLock().unlock();
         }
     }
 
@@ -178,45 +177,54 @@
     /**
      * Returns the total number of frame cache loads.
      *
      * @return total loads count
      */
     public long getTotalLoads() {
-        return totalLoads;
+        return totalLoads.sum();
     }
 
     /**
      * Returns the total number of cache hits.
      *
      * @return total hits count
      */
     public long getTotalHits() {
-        return totalHits;
+        return totalHits.sum();
     }
 
     /**
      * Returns the cache hit ratio (hits / total loads).
      *
      * @return hit ratio as a double between 0 and 1, or 0.0 if no loads have occurred
      */
     public double getHitRatio() {
-        if (totalLoads == 0) {
+        long loads = totalLoads.sum();
+        if (loads == 0) {
             return 0.0;
         }
-        return (double) totalHits / totalLoads;
+        return (double) totalHits.sum() / loads;
     }
 
     /**
      * Returns a summary string showing cache statistics.
      *
      * @return statistics string
      */
     @Override
     public String toString() {
-        return String.format("FrameCache[size=%d/%d, hits=%d, loads=%d, ratio=%.2f%%]",
-            size(), maxSize, totalHits, totalLoads, getHitRatio() * 100);
+        lock.readLock().lock();
+        try {
+            long loads = totalLoads.sum();
+            long hits = totalHits.sum();
+            double ratio = loads == 0 ? 0.0 : (double) hits / loads;
+            return String.format("FrameCache[size=%d/%d, hits=%d, loads=%d, ratio=%.2f%%]",
+                cache.size(), maxSize, hits, loads, ratio * 100);
+        } finally {
+            lock.readLock().unlock();
+        }
     }
 
     /**
      * Simple test of the FrameCache implementation.
      *
      * @param args command line arguments (unused)