     // we'll adjust the visibility in the completion block
     tripRequest.defaultVisibility = .hidden
     
-    for modeGroup in groupedIdentifier {
-      if self.workers[modeGroup] != nil {
-        continue
-      }
-      
-      let worker = TKRouter()
-      workers[modeGroup] = worker
-      worker.server = server
-      worker.modeIdentifiers = modeGroup
-      
-      worker.fetchTrips(for: tripRequest, additional: request.additional) { [weak self] result in
-        guard let self = self else { return }
+    queue.async {
+      self.cancelRequestsWorker()
+      self.isActive = true
+      
+      for modeGroup in groupedIdentifier {
+        if self.workers[modeGroup] != nil {
+          continue
+        }
         
-        self.finishedWorkers += 1
-        progress?(self.finishedWorkers)
+        let worker = TKRouter()
+        self.workers[modeGroup] = worker
+        worker.server = self.server
+        worker.modeIdentifiers = modeGroup
         
-        switch result {
-        case .failure(let error):
-          self.handleMultiFetchResult(.failure(error), modes: worker.modeIdentifiers, request: tripRequest, completion: completion)
+        worker.fetchTrips(for: tripRequest, additional: request.additional) { [weak self] result in
+          guard let self = self else { return }
           
-        case .success:
-          if modes == nil {
-            // We get the minimized and hidden modes here in the completion block
-            // since they might have changed while waiting for results
-            let minimized = TKUserProfileHelper.minimizedModeIdentifiers
-            let hidden = TKUserProfileHelper.hiddenModeIdentifiers
-            tripRequest.adjustVisibility(forMinimizedModeIdentifiers: minimized, hiddenModeIdentifiers: hidden)
-          } else {
-            tripRequest.adjustVisibility(forMinimizedModeIdentifiers: [], hiddenModeIdentifiers: [])
+          // Switch to update our internals in a thread-safe manner
+          queue.async {
+            self.finishedWorkers += 1
+            progress?(self.finishedWorkers)
+            
+            switch result {
+            case .failure(let error):
+              self.handleMultiFetchResult(.failure(error), modes: worker.modeIdentifiers, request: tripRequest, completion: completion)
+              
+            case .success:
+              // Classifiers will likely heavily read from the trips, so
+              // we need to switch
+              context.perform {
+                if modes == nil {
+                  // We get the minimized and hidden modes here in the completion block
+                  // since they might have changed while waiting for results
+                  let minimized = TKUserProfileHelper.minimizedModeIdentifiers
+                  let hidden = TKUserProfileHelper.hiddenModeIdentifiers
+                  tripRequest.adjustVisibility(forMinimizedModeIdentifiers: minimized, hiddenModeIdentifiers: hidden)
+                } else {
+                  tripRequest.adjustVisibility(forMinimizedModeIdentifiers: [], hiddenModeIdentifiers: [])
+                }
+                
+                // Updating classifications before making results visible
+                if let classifier = classifier {
+                  tripRequest.updateTripGroupClassifications(using: classifier)
+                }
+                
+                // Then back to worker queue to update internals
+                queue.async {
+                  self.handleMultiFetchResult(result, modes: worker.modeIdentifiers, request: tripRequest, completion: completion)
+                }
+              }
+            }
           }
-          
-          // Updating classifications before making results visible
-          if let classifier = classifier {
-            tripRequest.updateTripGroupClassifications(using: classifier)
-          }
-          
-          self.handleMultiFetchResult(result, modes: worker.modeIdentifiers, request: tripRequest, completion: completion)
         }
       }
     }

  }
  
  public func cancelRequests() {
    workers.map(\.value).forEach { $0.cancelRequests() }
    self.workers = [:]
    self.finishedWorkers = 0

      completion(.failure(RoutingError.invalidRequest("Could not access CoreData storage")))
      return 0
    }

    let enabledModes = modes ?? request.modes
    guard !enabledModes.isEmpty else {
