     
     // only called from the request queue
     internal func processLocationRequests() {
-        if let locationRequests = self._locationRequests {
-            guard
-                locationRequests.count > 0
-            else {
+        guard
+            self._locationRequests.count > 0
+        else {
+            self.executeClosureSyncOnMainQueueIfNecessary(withClosure: { 
                 self.delegate?.positionLocationManager(self, didUpdateTrackingLocations: self.locations)
-                return
-            }
+            })
+            return
+        }
+    
+        let completeRequests: [PositionLocationRequest] = self._locationRequests.filter { (request) -> Bool in
+            // check if a request completed, meaning expired or met horizontal accuracy
+            //print("desiredAccuracy \(request.desiredAccuracy) horizontal \(self.location?.horizontalAccuracy)")
+            if let location = self.locations?.first {
+                guard
+                    request.expired == true || location.horizontalAccuracy < request.desiredAccuracy
+                else {
+                    return false
+                }
+                return true
+            }
+            return false
+        }
         
-            let completeRequests: [PositionLocationRequest] = locationRequests.filter { (request) -> Bool in
-                // check if a request completed, meaning expired or met horizontal accuracy
-                //print("desiredAccuracy \(request.desiredAccuracy) horizontal \(self.location?.horizontalAccuracy)")
-                if let location = self.locations?.first {
-                    guard
-                        request.expired == true || location.horizontalAccuracy < request.desiredAccuracy
-                    else {
-                        return false
+        for request in completeRequests {
+            if request.completed == false {
+                request.completed = true
+                if request.expired == true {
+                    self.executeClosureSyncOnMainQueueIfNecessary {
+                        request.completionHandler?(nil, NSError(domain: ErrorDomain, code: ErrorType.timedOut.rawValue, userInfo: nil))
                     }
-                    return true
-                }
-                return false
-            }
-            
-            for request in completeRequests {
-                if let handler = request.completionHandler {
-                    if request.expired == true {
-                        let error = NSError(domain: ErrorDomain, code: ErrorType.timedOut.rawValue, userInfo: nil)
-                        handler(nil, error)
-                    } else {
-                        handler(self.locations?.first, nil)
+                } else {
+                    self.executeClosureSyncOnMainQueueIfNecessary {
+                        request.completionHandler?(self.locations?.first, nil)
                     }
                 }
-                if let index = locationRequests.index(of: request) {
-                    self._locationRequests?.remove(at: index)
-                }
-            }
+            }
+        }
+        
+        let pendingRequests: [PositionLocationRequest] = self._locationRequests.filter { (request) -> Bool in
+            request.completed == false
+        }
+        self._locationRequests = pendingRequests
+
+        if self._locationRequests.count == 0 {
+            self.updateLocationManagerStateIfNeeded()
             
-            if locationRequests.count == 0 {
-                self._locationRequests = nil
-                self.updateLocationManagerStateIfNeeded()
-                
-                if self.updatingLocation == false {
-                    self.stopUpdating()
-                }
-                
-                if self.updatingLowPowerLocation == false {
-                    self.stopLowPowerUpdating()
-                }
-            }
-        }
-    }
-    
-    internal func completeLocationRequestsWithError(_ error: Error?) {
-        if let locationRequests = self._locationRequests {
-            for locationRequest in locationRequests {
-                locationRequest.cancelRequest()
-                guard let handler = locationRequest.completionHandler else { continue }
-                if let resultingError = error {
-                    handler(nil, resultingError)
-                } else {
-                    handler(nil, NSError(domain: ErrorDomain, code: ErrorType.cancelled.rawValue, userInfo: nil))
-                }
+            if self.updatingLocation == false {
+                self.stopUpdating()
+            }
+            
+            if self.updatingLowPowerLocation == false {
+                self.stopLowPowerUpdating()
+            }
+        }
+    }
+    
+    internal func completeLocationRequests(withError error: Error?) {
+        for locationRequest in self._locationRequests {
+            locationRequest.cancelRequest()
+            guard
+                let handler = locationRequest.completionHandler
+            else {
+                continue
+            }
+            
+            self.executeClosureSyncOnMainQueueIfNecessary {
+                handler(nil, error ?? NSError(domain: ErrorDomain, code: ErrorType.cancelled.rawValue, userInfo: nil))
             }
         }
     }
 
     internal func updateLocationManagerStateIfNeeded() {
         // when not processing requests, set desired accuracy appropriately
-        if let locationRequests = self._locationRequests {
-            if locationRequests.count > 0 {
-                if self.updatingLocation == true {
-                    self._locationManager.desiredAccuracy = self.trackingDesiredAccuracyActive
-                } else if self.updatingLowPowerLocation == true {
-                    self._locationManager.desiredAccuracy = self.trackingDesiredAccuracyBackground
-                }
-                
-                self._locationManager.distanceFilter = self.distanceFilter
-            }
+        if self._locationRequests.count > 0 {
+            if self.updatingLocation == true {
+                self._locationManager.desiredAccuracy = self.trackingDesiredAccuracyActive
+            } else if self.updatingLowPowerLocation == true {
+                self._locationManager.desiredAccuracy = self.trackingDesiredAccuracyBackground
+            }
+            
+            self._locationManager.distanceFilter = self.distanceFilter
         }
     }
 }

            closure()
        } else {
            DispatchQueue.main.sync(execute: closure)
        }
    }
    

    
    @objc(locationManager:didUpdateLocations:)
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        self.executeClosureAsyncOnRequestQueueIfNecessary {
            // update last location
            self.locations = locations
            // update one-shot requests
            self.processLocationRequests()
        }
    }
    
    @objc(locationManager:didFailWithError:)
    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
        self.executeClosureAsyncOnRequestQueueIfNecessary {
            self.completeLocationRequests(withError: error)
            self.executeClosureSyncOnMainQueueIfNecessary {
                self.delegate?.positionLocationManager(self, didFailWithError: error)
            }
        }
    }
    
    @objc(locationManager:didChangeAuthorizationStatus:)
    func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
        self.executeClosureAsyncOnRequestQueueIfNecessary {
            switch status {
            case .denied, .restricted:
                self.completeLocationRequests(withError: NSError(domain: ErrorDomain, code: ErrorType.restricted.rawValue, userInfo: nil))
                break
            default:
                break
            }
            self.executeClosureSyncOnMainQueueIfNecessary {
                self.delegate?.positionLocationManager(self, didChangeLocationAuthorizationStatus: self.locationServicesStatus)
            }
        }
    }
    
    @objc(locationManager:didDetermineState:forRegion:)
