Changing an immutable data structure from two threads

Question

I use immutable data-structures as much as possible, because it's really easy to work with them. The problem though is when two threads modify the data-structure. In that case, the synchronized keyworks helped, but isn't one reason for immutable data-structures, to avoid synchroinzed?

What is the more idemoatic way to modify a immutable list from two threads?

data class MyEvent(val time: Long, val somethingElse: String)
class EventReceiver {
    private var events = listOf<MyEvent>()

    // called several times a second
    fun addEvent(e: MyEvent) {
        synchronized(this) {
            events += e
        }
    }

    // internal cron-trigger calls this every 10 seconds
    fun purge(olderThan: Long) {
        synchronized(this) {
            events = events.filter { it.time < olderThan }
        }
    }
}

Well immutable means that cannot be modified, which is not the case for your data structure (the `EventReceiver` object), isn't it? — user2340612, Jun 19 '18 at 09:27

score 2 · Accepted Answer · answered Jun 19 '18 at 10:02

2

Immutable data structures can not be mutated - it's in the name. That means there are no methods on it that modify its state. If there are, it's not immutable. Thus, your EventReceiver is not immutable and you need to design for data races to make it thread safe.

One of the ways to make data structures thread safe is using locks to guard access to the contested properties, such as using synchronized like you're doing here.

answered Jun 19 '18 at 10:02

nhaarman

98,571
55
246
278

Your right. But the question should target the question, how to handle mutabion of a immutable list from two threads. – guenhter Jun 19 '18 at 11:36
1

You can't. Like I said, an immutable list can not be mutated. – nhaarman Jun 19 '18 at 16:18

Changing an immutable data structure from two threads

1 Answers1