      */
     public override func execute() {
         switch delay.interval {
-        case (let interval) where interval > 0.0 && !isCancelled:
-            timer = DispatchSource.makeTimerSource(flags: [], queue: DispatchQueue.default)
-            timer?.setEventHandler { [weak self] in
-                guard let strongSelf = self else { return }
-                if !strongSelf.isCancelled { strongSelf.finish() }
+        case (let interval) where interval > 0.0:
+            let setupTimer = stateLock.withCriticalScope { () -> Bool in
+                guard !isCancelled else { return false }
+                _timer = DispatchSource.makeTimerSource(flags: [], queue: DispatchQueue.default)
+                _timer?.setEventHandler { [weak self] in
+                    guard let strongSelf = self else { return }
+                    if !strongSelf.isCancelled { strongSelf.finish() }
+                }
+                _timer?.scheduleOneshot(deadline: .now() + interval, leeway: self.leeway)
+                _timer?.resume()
+                return true
             }
-            timer?.scheduleOneshot(deadline: .now() + interval, leeway: leeway)
-            timer?.resume()
+            if !setupTimer { finish() }
         default:
             finish()
         }

        super.init()
        name = "Delay \(delay)"
        addDidCancelBlockObserver { procedure, _ in
            procedure.timer?.cancel()
        }
    }



    private let delay: Delay
    private let leeway: DispatchTimeInterval
    private var _timer: DispatchSourceTimer? = nil
    private let stateLock = NSLock()

    internal init(delay: Delay, leeway: DispatchTimeInterval = .milliseconds(1)) {
        self.delay = delay
