     fileprivate var stateHandlers: [FutureCompletionHandler<T>] = []
     
     internal init() {
-        FutureCounter = FutureCounter &+ 1
-        let queueName = "com.futuristics.future-queue\(FutureCounter)"
-        self.syncQueue = DispatchQueue(label: queueName, attributes: [])
+        self.syncQueue = DispatchQueue(label: "com.futuristics.future-queue")
+        let address = String(format: "Future<%p>", unsafeBitCast(self, to: Int.self))
+        self.syncQueue.setSpecific(key: futureIdentifierKey, value: address)
     }
     
     open func getResult() throws -> T {
-        switch self.state {
+        switch state {
         case .pending:
             throw FutureError.futureStillPending
         case .rejected(let error):

    }
    
    fileprivate func executeDeferedCompletionHandlers() {
        self.stateHandlers.forEach { self.executeCompletionHandler($0) }
        self.stateHandlers = []
    }

    fileprivate func executeCompletionHandler(_ handler: FutureCompletionHandler<T>) {
        switch (handler, self.state) {
        case (.success(let successHandler, let context), .fulfilled(let value)):
            _ = context { successHandler(value) }()
        case (.failure(let failureHandler, let context), .rejected(let error)):
            _ = context { failureHandler(error) }()
        case (.finally(let finalHandler, let context), _) where !self.state.isPending:
            _ = context { finalHandler() }()
        default: break
        }
    }
    
    fileprivate func deferCompletionHandler(_ handler: FutureCompletionHandler<T>) {
        self.stateHandlers.append(handler)
    }
    
    @discardableResult
    open func onSuccess(_ context: @escaping ExecutionContext = defaultExecutionContext, successHandler: @escaping (T) -> Void) -> Future<T> {
        self.syncQueue.async {
            let completionHandler = FutureCompletionHandler.success(task: successHandler, context: context)
            switch self.state {
            case .pending:
                self.deferCompletionHandler(completionHandler)

    }
    
    internal func fulfill(_ value: T) {
        guard case .pending = state else { return }
        self.syncQueue.sync { state = .fulfilled(value) }
        self.syncQueue.async {
            self.executeDeferedCompletionHandlers()
        }
    }
    
    internal func reject(_ error: Error) {
        guard case .pending = state else { return }
        self.syncQueue.sync { state = .rejected(error) }
        self.syncQueue.async {
            self.executeDeferedCompletionHandlers()
        }
