Is Scala's collection.mutable.PriorityQueue thread safe?

Question

I am using a PriorityQueue across multiple threads. I am not sure it's a thread safe data-structure.

Is it safe to use scala.collection.mutable.PriorityQueue across multiple threads?

Answer 1

TL;DR: It is not safe.

Let's have a look! scala.collection.mutable.PriorityQueue uses

private val resarr = new ResizableArrayAccess[A]

where ResizableArrayAccess is defined inside PriorityQueue as

private class ResizableArrayAccess[A] extends AbstractSeq[A] with ResizableArray[A] with Serializable {

From there, going to scala.collection.mutable.ResizableArray, it is obvious that this is not thread safe, e.g. by looking at the update method:

protected var array: Array[AnyRef] = new Array[AnyRef](math.max(initialSize, 1))
 // ... snip ... //
def update(idx: Int, elem: A) {
  if (idx >= size0) throw new IndexOutOfBoundsException(idx.toString)
  array(idx) = elem.asInstanceOf[AnyRef]
}

So we have unprotected access to a mutable var and usage of scala.collection.mutable.PriorityQueue from multiple Threads is not encouraged.

If you really need to use it from multiple threads and concurrency is not important you can use some meaning of synchronization, e.g. scala.util.SyncVar to protect against concurrency issues like race conditions. Otherwise using another data structure is better.