Swift 3, faire minuterie, ajouter au dictionnaire, ne sort jamais de

Question

Je Thing et ThingManager

Si personne ne parle pendant un certain temps un Thing spécifique, je veux ThingManager l'oublier. J'ai essayé les minuteries par bloc et les minuteries basées sur RunLoop. Ils ne semblent jamais à « partir »

struct Thing { 
    var name: String 
} 

class ThingManager { 
    var things: [String: Thing] = [:] 
    fileprivate var thingWatchingRunLoop = RunLoop() 
    fileprivate var thingWatchingQueue = DispatchQueue.global(qos: .utility) 
    fileprivate var thingWatchingTimers: [String: Timer] = [:] 

    func addThing(_ thing: Thing) { 
     self.things[thing.name] = thing 
    } 

    func sawSomeThing(named name: String) { 
     self.thingWatchingQueue.async { 
      // re-up the timer so we don't forget about that thing 
      if let timer = self.thingWatchingTimers[name] { 
       timer.invalidate() 
      } 
      let timer = Timer(timeInterval: 5.0, target: self, selector: #selector(self.timerWentOff(_:)), userInfo: ["name":name], repeats: false) 
      self.thingWatchingRunLoop.add(timer, forMode: .commonModes) 
      self.thingWatchingTimers[name] = timer 
     } 
    } 

    @objc func timerWentOff(_ timer: Timer) { 
     let info = timer.userInfo as! [String: String] 
     let name = info["name"] 
     self.removeThing(named: name!) 
    } 

    func removeThing(named name: String) { 
     self.things.removeValue(forKey: name) 
    } 
} 

mise à jour, la version à base de blocs: https://gist.github.com/lacyrhoades/f917b971e97fdecf9607669501ef6512

Answer 1

Je crois que vous avez juste besoin d'ajouter la minuterie à la runloop actuelle au lieu de créer une nouvelle instance runloop .

Change:

fileprivate var thingWatchingRunLoop = RunLoop() 

à:

fileprivate var thingWatchingRunLoop = RunLoop.current 

et tout devrait fonctionner correctement!

Answer 2

plutôt qu'une minuterie par Thing j'attribuer un intervalle de caducité à chaque Thing dans ThingManager et une seule minuterie:

struct Thing { 
    var name: String 
} 

extension Thing: Equatable { 
    static func ==(lhs: Thing, rhs: Thing) -> Bool { 
     return lhs.name == rhs.name 
    } 
} 

extension Thing: Hashable { 
    var hashValue: Int { 
     return name.hashValue 
    } 
} 

class ThingManager { 
    let stalenessInterval: TimeInterval = -5 
    var things = [String: Thing]() 
    var staleness = [Thing: Date]() 
    fileprivate var pruningTimer: DispatchSourceTimer! 

    init() { 
     pruningTimer = DispatchSource.makeTimerSource(queue: .main) 
     pruningTimer.scheduleRepeating(deadline: DispatchTime.now(), interval: DispatchTimeInterval.milliseconds(500)) 
     pruningTimer.setEventHandler() { 
      for (name, thing) in self.things { 
       if let date = self.staleness[thing], date.timeIntervalSinceNow < self.stalenessInterval { 
        self.removeThing(named: name) 
       } 
      } 
     } 
     pruningTimer.resume() 
    } 

    func addThing(_ thing: Thing) { 
     things[thing.name] = thing 
    } 

    func sawSomeThing(named name: String) { 
     if let thing = things[name] { 
      staleness[thing] = Date() 
     } 
    } 

    func removeThing(named name: String) { 
     if let removedThing = things.removeValue(forKey: name) { 
      staleness.removeValue(forKey: removedThing) 
     } 
    } 
}