diff --git a/chat-android/src/main/java/com/ably/chat/PriorityExecutor.kt b/chat-android/src/main/java/com/ably/chat/AtomicExecutor.kt
similarity index 52%
rename from chat-android/src/main/java/com/ably/chat/PriorityExecutor.kt
rename to chat-android/src/main/java/com/ably/chat/AtomicExecutor.kt
index f5d5b94e..3bac6b05 100644
--- a/chat-android/src/main/java/com/ably/chat/PriorityExecutor.kt
+++ b/chat-android/src/main/java/com/ably/chat/AtomicExecutor.kt
@@ -6,37 +6,37 @@ import kotlinx.coroutines.async
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.launch
 
-private class OrderedCoroutine(
+private class Task(
     private val priority: Int,
-    val suspendedFn: suspend CoroutineScope.() -> Any,
+    val coroutineBlock: suspend CoroutineScope.() -> Any,
     val resultChannel: Channel<Result<Any>>)
-    : Comparable<OrderedCoroutine> {
-        override fun compareTo(other: OrderedCoroutine): Int {
+    : Comparable<Task> {
+        override fun compareTo(other: Task): Int {
             return other.priority - this.priority
         }
 }
 
 /**
- * Aim of PriorityExecutor is to execute given coroutine operation mutually exclusive.
+ * Aim of AtomicExecutor is to execute given coroutine operation mutually exclusive.
  * @property scope Uses single threaded dispatcher to avoid thread synchronization issues.
  */
-class PriorityExecutor(private val scope: CoroutineScope) {
+class AtomicExecutor(private val scope: CoroutineScope) {
     private var isRunning = false
-    private val priorityQueue: PriorityQueue<OrderedCoroutine> = PriorityQueue()
+    private val priorityQueue: PriorityQueue<Task> = PriorityQueue()
 
-    suspend fun <T : Any>execute(priority:Int, suspendedFun: suspend CoroutineScope.() -> T) : Channel<Result<T>> {
+    suspend fun <T : Any>execute(priority:Int, coroutineBlock: suspend CoroutineScope.() -> T) : Channel<Result<T>> {
         // Size of resultChannel is set to 1 to keep while loop running.
-        // i.e. If other end doesn't call receive on the channel, loop will be blocked.
+        // i.e. If caller doesn't explicitly receive on the channel, loop will be blocked.
         val resultChannel = Channel<Result<Any>>(1)
-        priorityQueue.add(OrderedCoroutine(priority, suspendedFun, resultChannel))
+        priorityQueue.add(Task(priority, coroutineBlock, resultChannel))
 
         scope.launch {
             if (!isRunning) {
                 isRunning = true
                 while (priorityQueue.size > 0) {
-                    val runningCoroutine = priorityQueue.remove()
-                    val result = kotlin.runCatching { scope.async(block = runningCoroutine.suspendedFn).await() }
-                    runningCoroutine.resultChannel.send(result)
+                    val task = priorityQueue.remove()
+                    val result = kotlin.runCatching { scope.async(block = task.coroutineBlock).await() }
+                    task.resultChannel.send(result)
                 }
                 isRunning = false
             }