Scalability for Millions of Concurrent Mobile Users Questions

import java.util.LinkedHashMap
import java.util.concurrent.locks.ReentrantLock
import kotlin.concurrent.withLock

data class Event(val id: String, val payload: String, val priority: Int)

class DedupQueue(private val maxSize: Int) {
    init { require(maxSize > 0) { "maxSize must be > 0" } }

    // preserves insertion order of keys
    private val map = LinkedHashMap<String, Event>(16, 0.75f, false)
    private val lock = ReentrantLock()

    // Enqueue or update existing event. Returns false if dropped due to full capacity.
    fun enqueue(event: Event): Boolean {
        lock.withLock {
            if (map.containsKey(event.id)) {
                // replace value but keep order -> remove then put to maintain original insertion order we want to preserve.
                // To preserve original insertion order, simply replace the value:
                map[event.id] = event
                return true
            } else {
                if (map.size >= maxSize) return false
                map[event.id] = event
                return true
            }
        }
    }

    // Drain up to maxBatch events in insertion order of unique ids
    fun drain(maxBatch: Int): List<Event> {
        require(maxBatch >= 0)
        lock.withLock {
            if (map.isEmpty() || maxBatch == 0) return emptyList()
            val out = ArrayList<Event>(minOf(maxBatch, map.size))
            val iter = map.entries.iterator()
            while (iter.hasNext() && out.size < maxBatch) {
                val e = iter.next()
                out.add(e.value)
                iter.remove()
            }
            return out
        }
    }

    // Optional helpers
    fun size(): Int = lock.withLock { map.size }
    fun clear() = lock.withLock { map.clear() }
}