Make ByteBufferRandomAccessSource thread safe

DEVSIX-6279

Author: Alexander Kozlov

io/src/main/java/com/itextpdf/io/source/ByteBufferRandomAccessSource.java

@@ -44,20 +44,24 @@ This file is part of the iText (R) project.
 package com.itextpdf.io.source;
 
 import java.lang.reflect.Method;
-import java.nio.Buffer;
 import java.nio.BufferUnderflowException;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-
 /**
- * A RandomAccessSource that is based on an underlying {@link java.nio.ByteBuffer}.  This class takes steps to ensure that the byte buffer
+ * A RandomAccessSource that is based on an underlying {@link java.nio.ByteBuffer}.  This class takes steps to ensure
+ * that the byte buffer
  * is completely freed from memory during {@link ByteBufferRandomAccessSource#close()}
  */
 class ByteBufferRandomAccessSource implements IRandomAccessSource {
 
+    /**
+     * A flag to allow unmapping hack for cleaning mapped buffer
+     */
+    private static boolean allowUnmapping = true;
+
     /**
      * Internal cache of memory mapped buffers
      */
@@ -72,6 +76,13 @@ public ByteBufferRandomAccessSource(java.nio.ByteBuffer byteBuffer) {
         this.byteBuffer = byteBuffer;
     }
 
+    /**
+     * Enables unmapping hack
+     */
+    public static void disableUnmapping() {
+        allowUnmapping = false;
+    }
+
     /**
      * {@inheritDoc}
      * <p>
@@ -80,14 +91,15 @@ public ByteBufferRandomAccessSource(java.nio.ByteBuffer byteBuffer) {
      * @param position the position to read the byte from - must be less than Integer.MAX_VALUE
      */
     public int get(long position) {
-        if (position > Integer.MAX_VALUE)
+        if (position > Integer.MAX_VALUE) {
             throw new IllegalArgumentException("Position must be less than Integer.MAX_VALUE");
+        }
         try {
 
-            if (position >= ((Buffer) byteBuffer).limit())
+            if (position >= byteBuffer.limit()) {
                 return -1;
-            byte b = byteBuffer.get((int) position);
-            return b & 0xff;
+            }
+            return byteBuffer.duplicate().get((int) position) & 0xff;
         } catch (BufferUnderflowException e) {
             // EOF
             return -1;
@@ -102,16 +114,18 @@ public int get(long position) {
      * @param position the position to read the byte from - must be less than Integer.MAX_VALUE
      */
     public int get(long position, byte[] bytes, int off, int len) {
-        if (position > Integer.MAX_VALUE)
+        if (position > Integer.MAX_VALUE) {
             throw new IllegalArgumentException("Position must be less than Integer.MAX_VALUE");
+        }
 
-        if (position >= ((Buffer) byteBuffer).limit())
+        if (position >= byteBuffer.limit()) {
             return -1;
+        }
 
-        // Not thread safe!
-        ((Buffer) byteBuffer).position((int) position);
-        int bytesFromThisBuffer = Math.min(len, byteBuffer.remaining());
-        byteBuffer.get(bytes, off, bytesFromThisBuffer);
+        final java.nio.ByteBuffer byteBufferCopy = byteBuffer.duplicate();
+        byteBufferCopy.position((int) position);
+        final int bytesFromThisBuffer = Math.min(len, byteBufferCopy.remaining());
+        byteBufferCopy.get(bytes, off, bytesFromThisBuffer);
 
         return bytesFromThisBuffer;
     }
@@ -121,15 +135,17 @@ public int get(long position, byte[] bytes, int off, int len) {
      * {@inheritDoc}
      */
     public long length() {
-        return ((Buffer) byteBuffer).limit();
+        return byteBuffer.limit();
     }
 
     /**
      * @see java.io.RandomAccessFile#close()
      * Cleans the mapped bytebuffers and closes the channel
      */
     public void close() throws java.io.IOException {
-        clean(byteBuffer);
+        if (allowUnmapping) {
+            clean(byteBuffer);
+        }
     }
 
 
@@ -144,11 +160,8 @@ public void close() throws java.io.IOException {
     private static final BufferCleaner CLEANER;
 
     static {
-        final Object hack = AccessController.doPrivileged(new PrivilegedAction<Object>() {
-            public Object run() {
-                return BufferCleaner.unmapHackImpl();
-            }
-        });
+        final Object hack = AccessController.doPrivileged(
+                (PrivilegedAction<Object>) BufferCleaner::unmapHackImpl);
         if (hack instanceof BufferCleaner) {
             CLEANER = (BufferCleaner) hack;
             UNMAP_SUPPORTED = true;
@@ -162,37 +175,38 @@ public Object run() {
      * invokes the clean method on the ByteBuffer's cleaner
      *
      * @param buffer ByteBuffer
+     *
      * @return boolean true on success
      */
     private static boolean clean(final java.nio.ByteBuffer buffer) {
-        if (buffer == null || !buffer.isDirect())
+        if (buffer == null || !buffer.isDirect()) {
             return false;
+        }
 
-        Boolean b = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
-            public Boolean run() {
-                Boolean success = Boolean.FALSE;
-                try {
-                    // java 9
-                    if (UNMAP_SUPPORTED)
-                        CLEANER.freeBuffer(buffer.toString(), buffer);
-                    // java 8 and lower
-                    else {
-                        Method getCleanerMethod = buffer.getClass().getMethod("cleaner", (Class<?>[]) null);
-                        getCleanerMethod.setAccessible(true);
-                        Object cleaner = getCleanerMethod.invoke(buffer, (Object[]) null);
-                        Method clean = cleaner.getClass().getMethod("clean", (Class<?>[]) null);
-                        clean.invoke(cleaner, (Object[]) null);
-                    }
-                    success = Boolean.TRUE;
-                } catch (Exception e) {
-                    // This really is a show stopper on windows
-                    Logger logger = LoggerFactory.getLogger(ByteBufferRandomAccessSource.class);
-                    logger.debug(e.getMessage());
-                }
-                return success;
-            }
-        });
+        return AccessController.doPrivileged((PrivilegedAction<Boolean>) () -> cleanByUnmapping(buffer));
+    }
 
-        return b;
+    private static boolean cleanByUnmapping(final java.nio.ByteBuffer buffer) {
+        Boolean success = Boolean.FALSE;
+        try {
+            // java 9
+            if (UNMAP_SUPPORTED) {
+                CLEANER.freeBuffer(buffer.toString(), buffer);
+            }
+            // java 8 and lower
+            else {
+                Method getCleanerMethod = buffer.getClass().getMethod("cleaner", (Class<?>[]) null);
+                getCleanerMethod.setAccessible(true);
+                Object cleaner = getCleanerMethod.invoke(buffer, (Object[]) null);
+                Method clean = cleaner.getClass().getMethod("clean", (Class<?>[]) null);
+                clean.invoke(cleaner, (Object[]) null);
+            }
+            success = Boolean.TRUE;
+        } catch (Exception e) {
+            // This really is a show stopper on windows
+            Logger logger = LoggerFactory.getLogger(ByteBufferRandomAccessSource.class);
+            logger.debug(e.getMessage());
+        }
+        return success;
     }
 }