use linkedhashset for ringset

src/main/kotlin/io/emeraldpay/dshackle/data/RingSet.kt

@@ -5,40 +5,36 @@ import java.util.concurrent.atomic.AtomicReference
 class RingSet<T>(
     private val maxSize: Int
 ) : Set<T> {
-    private var seqValues: AtomicReference<List<T>> = AtomicReference(emptyList())
+    private var setRef: AtomicReference<LinkedHashSet<T>> = AtomicReference(LinkedHashSet<T>())
-    private var set: Set<T> = emptySet()
     override val size: Int
-        get() = set.size
+        get() = setRef.get().size
 
     fun add(element: T) {
-        if (set.contains(element)) {
+        setRef.getAndUpdate { set ->
-            return
+            if (!set.contains(element)) {
-        }
+                val copyset = LinkedHashSet<T>(set)
-        seqValues.getAndUpdate { vals ->
+                copyset.add(element)
-            vals.let {
+                if (copyset.size > maxSize) {
-                if (vals.size > maxSize) {
+                    copyset.remove(set.elementAt(0))
-                    vals.drop(1)
-                } else {
-                    vals
                 }
-            }.plus(element).let {
+                copyset
-                set = HashSet(it)
+            } else {
-                it
+                set
             }
         }
     }
 
     override fun isEmpty(): Boolean {
-        return set.isEmpty()
+        return setRef.get().isEmpty()
     }
     override fun contains(element: @UnsafeVariance T): Boolean {
-        return set.contains(element)
+        return setRef.get().contains(element)
     }
     override fun iterator(): Iterator<T> {
-        return set.iterator()
+        return setRef.get().iterator()
     }
 
     override fun containsAll(elements: Collection<@UnsafeVariance T>): Boolean {
-        return set.containsAll(elements)
+        return setRef.get().containsAll(elements)
     }
 }

src/main/kotlin/io/emeraldpay/dshackle/upstream/forkchoice/NoChoiceWithPriorityForkChoice.kt

@@ -9,7 +9,7 @@ class NoChoiceWithPriorityForkChoice(
     private val nodeRating: Int
 ) : ForkChoice {
     private val head = AtomicReference<BlockContainer>(null)
-    private val seenBlocks = RingSet<BlockId>(10)
+    private val seenBlocks = RingSet<BlockId>(100)
 
     override fun getHead(): BlockContainer? {
         return head.get()