Increase concurrency in NativeMappedConverter using reentrant lock

src/com/sun/jna/NativeMappedConverter.java

@@ -25,27 +25,39 @@
 
 import java.lang.ref.Reference;
 import java.lang.ref.SoftReference;
-import java.lang.reflect.InvocationTargetException;
 import java.util.Map;
 import java.util.WeakHashMap;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 /** Provides type conversion for instances of {@link NativeMapped}. */
 public class NativeMappedConverter implements TypeConverter {
+    private static final ReentrantReadWriteLock mapLock = new ReentrantReadWriteLock();
     private static final Map<Class<?>, Reference<NativeMappedConverter>> converters =
             new WeakHashMap<>();
     private final Class<?> type;
     private final Class<?> nativeType;
     private final NativeMapped instance;
 
     public static NativeMappedConverter getInstance(Class<?> cls) {
-        synchronized(converters) {
-            Reference<NativeMappedConverter> r = converters.get(cls);
-            NativeMappedConverter nmc = r != null ? r.get() : null;
-            if (nmc == null) {
-                nmc = new NativeMappedConverter(cls);
-                converters.put(cls, new SoftReference<>(nmc));
+        mapLock.readLock().lock();
+        try {
+            Reference<NativeMappedConverter> ref = converters.get(cls);
+            if (ref != null) {
+                return ref.get();
             }
-            return nmc;
+        } finally {
+            mapLock.readLock().unlock();
+        }
+
+        mapLock.writeLock().lock();
+        try {
+            return converters.computeIfAbsent(cls, (clz) -> {
+                NativeMappedConverter nmc = new NativeMappedConverter(cls);
+                return new SoftReference<>(nmc);
+            }).get();
+        }
+        finally {
+            mapLock.writeLock().unlock();
         }
     }