[GAIA-2057] Loading the Map with the interfaceType processed by implicit is now thread-safe (cheap protection by adding a lock)

Author: alberto-ls1

src/main/kotlin/implicit/Implicit.kt

@@ -18,6 +18,7 @@ import net.bytebuddy.matcher.ElementMatchers.isDeclaredBy
 import java.lang.reflect.InvocationTargetException
 import java.lang.reflect.Method
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.locks.ReentrantLock
 import java.util.function.Function
 import java.util.function.Supplier
 import java.util.stream.Collectors
@@ -30,37 +31,40 @@ class Implicit(val namingStrategy: (TypeDescription) -> CharSequence) {
     companion object {
         private val intfTypeRegistry = ConcurrentHashMap<String, String>()
         private val supplierRegistry = ConcurrentHashMap<String, Supplier<*>>()
+        private val intfTypeRegistryLock = ReentrantLock()
+
     }
 
     @JvmOverloads
     @Suppress("UNCHECKED_CAST")
     fun <T> create(intf: Class<T>, interceptor: ImplicitInterceptor = ImplicitInterceptor()): Class<out T> {
         if (!intf.isInterface)
             throw IllegalArgumentException("argument must be an interface")
-
-        if (intfTypeRegistry.containsKey(intf.name))
-            return Class.forName(intfTypeRegistry.get(intf.name)) as Class<out T>
-
-        val addField = AddFieldDecorator<T>(intf)::apply
-        val addGetterSetter = AddGetterSetterDecorator<T>(intf)::apply
-        val addConstructor = AddConstructorDecorator<T>(intf, interceptor)::apply
-        val addAlias = AliasDecorator<T>(intf)::apply
-        val addMixin = MixinDecorator<T>(intf)::apply
-        val addEqualsHashCode = AddEqualsHashCodeDecorator<T>(intf)::apply
-        val addToString = AddToStringDecorator<T>(intf)::apply
-        val toMap = ToMapDecorator<T>(intf)::apply
-
-        val unloaded = toMap(addToString(addEqualsHashCode(
-                addMixin(addAlias(addGetterSetter(addField(addConstructor(init(intf))))))))).make()
-        interceptor.onLoading(unloaded)
-
-        val loaded = unloaded.load(Implicit::class.java.classLoader, INJECTION)
-        interceptor.onLoaded(loaded)
-
-        val loadedType = loaded.loaded
-        intfTypeRegistry.put(intf.name, loadedType.name)
-
-        return loadedType
+        try {
+            intfTypeRegistryLock.lock()
+            if (intfTypeRegistry.containsKey(intf.name))
+                return Class.forName(intfTypeRegistry.get(intf.name)) as Class<out T>
+
+            val addField = AddFieldDecorator<T>(intf)::apply
+            val addGetterSetter = AddGetterSetterDecorator<T>(intf)::apply
+            val addConstructor = AddConstructorDecorator<T>(intf, interceptor)::apply
+            val addAlias = AliasDecorator<T>(intf)::apply
+            val addMixin = MixinDecorator<T>(intf)::apply
+            val addEqualsHashCode = AddEqualsHashCodeDecorator<T>(intf)::apply
+            val addToString = AddToStringDecorator<T>(intf)::apply
+            val toMap = ToMapDecorator<T>(intf)::apply
+
+            val unloaded = toMap(addToString(addEqualsHashCode(
+                    addMixin(addAlias(addGetterSetter(addField(addConstructor(init(intf))))))))).make()
+            interceptor.onLoading(unloaded)
+            val loaded = unloaded.load(Implicit::class.java.classLoader, INJECTION)
+            interceptor.onLoaded(loaded)
+            val loadedType = loaded.loaded
+            intfTypeRegistry.put(intf.name, loadedType.name)
+            return loadedType
+        } finally {
+            intfTypeRegistryLock.unlock()
+        }
     }
 
     @Suppress("UNCHECKED_CAST")

src/test/kotlin/implicit/ImplicitTest.kt

@@ -14,13 +14,15 @@
  * from Leftshift One.
  */
 
-package implicit;
+package implicit
 
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Assertions.assertNotNull
-import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 import java.util.*
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
 
 class ImplicitTest {
 
@@ -37,7 +39,32 @@ class ImplicitTest {
 
         assertNotNull(pojo.getPartitionKey())
         assertNotNull(pojo.getSortingKey())
-        Assertions.assertTrue(pojo::class.java.annotations.map { it.annotationClass.simpleName }.contains("Entity"))
+        assertTrue(pojo::class.java.annotations.map { it.annotationClass.simpleName }.contains("Entity"))
+    }
+
+    @Test
+    fun parallelTest() {
+        var creationOfPojoSuccessfull=true
+        val barrier = CountDownLatch(1)
+        val endBarrier = CountDownLatch(25)
+        val factory = Implicit { "implicit.test.implicit.${it.simpleName}" }
+        (0..24).forEach {
+            Thread {
+                try {
+                    barrier.await(10, TimeUnit.SECONDS)
+                    println("[${Thread.currentThread().name}] starting execution")
+                    factory.create(IPojo::class.java)
+                }catch (ex: Exception){
+                    println("[${Thread.currentThread().name}] Error occurred when creating the pojo " + ex.message)
+                    creationOfPojoSuccessfull=false
+                } finally {
+                    endBarrier.countDown()
+                }
+            }.start()
+        }
+        barrier.countDown()
+        endBarrier.await(60, TimeUnit.SECONDS)
+        assertThat(creationOfPojoSuccessfull).isTrue()
     }
 
     @Test
@@ -50,7 +77,7 @@ class ImplicitTest {
 
         assertNotNull(pojo.getPartitionKey())
         assertNotNull(pojo.getSortingKey())
-        Assertions.assertTrue(pojo::class.java.annotations.map { it.annotationClass.simpleName }.contains("Entity"))
+        assertTrue(pojo::class.java.annotations.map { it.annotationClass.simpleName }.contains("Entity"))
     }
 
     @Test
@@ -118,7 +145,7 @@ class ImplicitTest {
         fun setPartitionKey(str: String)
 
         fun getSortingKey(): String
-        fun setSortingKey(str: String): Unit
+        fun setSortingKey(str: String)
 
         fun getLabelList(): List<String?>
         fun setLabelList(labelList: List<String?>)