Comment puis-je créer un NSTimer sur un thread d'arrière-plan?

La minuterie doivent être installés dans une course boucle d'exploitation sur une déjà en cours d'exécution thread d'arrière-plan. Ce thread devrait continuer à l'exécution de l'exécution de la boucle pour avoir la minuterie en fait le feu. Et pour que le thread d'arrière-plan pour continuer à être en mesure de tirer d'autres événements de la minuterie, il faut générer un nouveau thread pour en fait de gérer les événements de toute façon (en supposant, bien sûr, que le traitement que vous faites prend beaucoup de temps).

Pour ce qu'il vaut, je pense que la manipulation événements de la minuterie en lançant un nouveau thread à l'aide de Grand Central Dispatch ou NSBlockOperation est parfaitement raisonnable de l'utilisation de votre thread principal.

Si vous voulez aller pure PGCD et utiliser une dépêche de source, Apple a un exemple de code pour cela dans leurs La Simultanéité Guide De Programmation:

dispatch_source_t CreateDispatchTimer(uint64_t interval, uint64_t leeway, dispatch_queue_t queue, dispatch_block_t block)
{
    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
    if (timer)
    {
        dispatch_source_set_timer(timer, dispatch_walltime(NULL, 0), interval, leeway);
        dispatch_source_set_event_handler(timer, block);
        dispatch_resume(timer);
    }
    return timer;
}

Swift 3:

func createDispatchTimer(interval: DispatchTimeInterval,
                         leeway: DispatchTimeInterval,
                         queue: DispatchQueue,
                         block: @escaping ()->()) -> DispatchSourceTimer {
    let timer = DispatchSource.makeTimerSource(flags: DispatchSource.TimerFlags(rawValue: 0),
                                               queue: queue)
    timer.scheduleRepeating(deadline: DispatchTime.now(),
                            interval: interval,
                            leeway: leeway)

    //Use DispatchWorkItem for compatibility with iOS 9. Since iOS 10 you can use DispatchSourceHandler
    let workItem = DispatchWorkItem(block: block)
    timer.setEventHandler(handler: workItem)
    timer.resume()
    return timer
}

Vous pouvez mettre en place votre un deuxième événement de minuterie à l'aide d'un code comme le suivant:

dispatch_source_t newTimer = CreateDispatchTimer(1ull * NSEC_PER_SEC, (1ull * NSEC_PER_SEC) / 10, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    //Repeating task
});

faire assurez-vous de stocker et de libérer votre minuterie de fait, bien sûr. Ci-dessus vous donne un 1/10e de seconde de marge de manœuvre sur le tir de ces événements, ce qui peut se resserrer si vous le souhaitez.

Pour swift 3.0

Tikhonv réponse n'explique pas trop. Ici, ajoute un peu de ma compréhension.

À faire les choses à court d'abord, voici le code. Il est DIFFÉRENTS de Tikhonv du code à l'endroit où j'ai créer le minuteur. J'ai créer le minuteur à l'aide de constructeur et l'ajouter dans la boucle. Je pense que le scheduleTimer fonction ajouter le minuteur sur le thread principal de l'RunLoop. Donc, il est préférable de créer de la minuterie en utilisant le constructeur.

class RunTimer{
  let queue = DispatchQueue(label: "Timer", qos: .background, attributes: .concurrent)
  let timer: Timer?

  private func startTimer() {
    //schedule timer on background
    queue.async { [unowned self] in
      if let _ = self.timer {
        self.timer?.invalidate()
        self.timer = nil
      }
      let currentRunLoop = RunLoop.current
      self.timer = Timer(timeInterval: self.updateInterval, target: self, selector: #selector(self.timerTriggered), userInfo: nil, repeats: true)
      currentRunLoop.add(self.timer!, forMode: .commonModes)
      currentRunLoop.run()
    }
  }

  func timerTriggered() {
    //it will run under queue by default
    debug()
  }

  func debug() {
     //print out the name of current queue
     let name = __dispatch_queue_get_label(nil)
     print(String(cString: name, encoding: .utf8))
  }

  func stopTimer() {
    queue.sync { [unowned self] in
      guard let _ = self.timer else {
        //error, timer already stopped
        return
      }
      self.timer?.invalidate()
      self.timer = nil
    }
  }
}

Créer Une File D'Attente

Tout d'abord, créez une file d'attente pour faire de la minuterie s'exécuter en arrière-plan et de les stocker en tant que liste de propriétés de la classe afin de le réutiliser pour arrêter la minuterie. Je ne suis pas sûr si nous devons utiliser la même file d'attente pour démarrer et arrêter, la raison pour laquelle je l'ai fait c'est parce que j'ai vu un message d'avertissement ici.

La RunLoop classe est généralement pas considérés comme des être thread-safe et
ses méthodes ne doivent être appelées dans le contexte actuel de la
fil de discussion. Vous ne devriez jamais tenter d'appeler les méthodes d'un objet RunLoop
exécute dans un thread différent, car cela pourrait provoquer inattendu
résultats.

J'ai donc décidé de stocker la file d'attente et d'utiliser la même file d'attente pour le compte à rebours pour éviter les problèmes de synchronisation.

Également créer un vide minuterie et stockée dans la variable de classe ainsi. Le rendre facultatif de sorte que vous pouvez arrêter la minuterie et réglez à néant.

class RunTimer{
  let queue = DispatchQueue(label: "Timer", qos: .background, attributes: .concurrent)
  let timer: Timer?
}

Démarrer La Minuterie

Pour démarrer la minuterie, le premier appel asynchrone à partir de DispatchQueue. Alors c'est une bonne pratique de vérifier d'abord si le compte à rebours est déjà commencé. Si la minuterie variable n'est pas nulle, alors invalidate() et mis à néant.

La prochaine étape est d'obtenir le courant RunLoop. Parce que nous l'avons fait dans le bloc de file d'attente, nous avons créé, il pourra obtenir les RunLoop pour le fond de la file d'attente que nous avons créé auparavant.

Créer de la minuterie. Ici, au lieu d'utiliser scheduledTimer, il suffit d'appeler le constructeur de la minuterie et de passer à ce que la propriété que vous voulez pour la minuterie comme timeInterval, cible, sélecteur, etc.

Ajouter à la création de la minuterie à la RunLoop. L'exécuter.

Voici une question à propos de l'exécution de la RunLoop. Selon la documentation ici, dit-il, il a effectivement commence une boucle infinie qui traite des données à partir de l'exécution de la boucle sources d'entrée et les minuteries.

private func startTimer() {
  //schedule timer on background
  queue.async { [unowned self] in
    if let _ = self.timer {
      self.timer?.invalidate()
      self.timer = nil
    }

    let currentRunLoop = RunLoop.current
    self.timer = Timer(timeInterval: self.updateInterval, target: self, selector: #selector(self.timerTriggered), userInfo: nil, repeats: true)
    currentRunLoop.add(self.timer!, forMode: .commonModes)
    currentRunLoop.run()
  }
}

De Déclenchement Minuterie

Mettre en œuvre la fonction normale. Lorsque cette fonction est appelée, elle est appelée, en vertu de la file d'attente par défaut.

func timerTriggered() {
  //under queue by default
  debug()
}

func debug() {
  let name = __dispatch_queue_get_label(nil)
  print(String(cString: name, encoding: .utf8))
}

La fonction ci-dessus est à utiliser pour imprimer le nom de la file d'attente. Si jamais vous vous inquiétez pas si il a été en cours d'exécution sur la file d'attente, vous pouvez l'appeler pour vérifier.

Arrêter La Minuterie

Arrêter la minuterie est facile, appel valider() et réglez la minuterie variable stockée à l'intérieur de la classe à néant.

Ici, je suis en cours d'exécution en vertu de la file d'attente à nouveau. En raison de l'avertissement ici j'ai décidé de courir toute la minuterie du code connexe en vertu de la file d'attente pour éviter les conflits.

func stopTimer() {
  queue.sync { [unowned self] in
    guard let _ = self.timer else {
      //error, timer already stopped
      return
    }
    self.timer?.invalidate()
    self.timer = nil
  }
}

Questions liées à la RunLoop

Je suis en quelque sorte un peu confus sur si nous avons besoin d'arrêter manuellement le RunLoop ou pas. Selon la documentation, il semble que, lorsque aucun des minuteries attaché à elle, alors elle sort immédiatement. Alors, quand nous avons l'arrêt de la minuterie, il doit existe lui-même. Cependant, à la fin de ce document, il a dit aussi:

la suppression connues de tous les sources d'entrée et les minuteries de l'exécution de la boucle n'est pas un
garantir que l'exécution de la boucle de sortie. macOS pouvez installer et à enlever
entrée supplémentaire sources nécessaires pour traiter les demandes ciblées à l'
récepteur du fil. Ces sources pourrait donc empêcher l'exécution de la boucle
de sortie.

J'ai essayé la solution ci-dessous qui sont fournis dans la documentation pour une garantie de terminer la boucle. Cependant, la minuterie ne se déclenche pas après que j'ai changer .run() pour le code ci-dessous.

while (self.timer != nil && currentRunLoop.run(mode: .commonModes, before: Date.distantFuture)) {};

Ce que je pense, c'est qu'il pourrait être sûr pour que l'aide .run() sur iOS. Parce que la documentation indique que macOS est d'installer et de retirer d'autres sources d'entrée nécessaires pour traiter les demandes ciblant le récepteur du fil. Donc iOS pourrait être bien.

Swift seulement (mais peut probablement être modifié pour une utilisation avec Objective-C)

Découvrez DispatchTimer de https://github.com/arkdan/ARKExtensions, qui "Exécute une fermeture sur l'expédition de la file d'attente, avec des intervalles de temps spécifiés, pour un nombre spécifié de fois (en option). "

let queue = DispatchQueue(label: "ArbitraryQueue")
let timer = DispatchTimer(timeInterval: 1, queue: queue) { timer in
    //body to execute until cancelled by timer.cancel()
}

class BgLoop:Operation{
    func main(){
        while (!isCancelled) {
            sample();
            Thread.sleep(forTimeInterval: 1);
        }
    }
}