11

Timers Written by Florent Pillet

Repeating and non-repeating timers are always useful when coding. Besides executing code asynchronously, you often need to control when and how often a task should repeat.

Before the Dispatch framework was available, developers relied on RunLoop to asynchronously perform tasks and implement concurrency. Timer (NSTimer in Objective-C) could be used to create repeating and non-repeating timers. Then Dispatch arrived and with it, DispatchSourceTimer.

Although all of the above are capable of creating timers, not all timers are equal in Combine. Read on!

Using RunLoop

The main thread and any thread you create, preferably using the Thread class, can have its own RunLoop. Just invoke RunLoop.current from the current thread: Foundation would create one for you if needed. Beware, unless you understand how run loops operate — in particular, that you need a loop that runs the run loop — you’ll be better off simply using the main RunLoop that runs the main thread of your application.

Note: One important note and a red light warning in Apple’s documentation is that the RunLoop class is not thread-safe. You should only call RunLoop methods for the run loop of the current thread.

RunLoop implements the Scheduler protocol you’ll learn about in Chapter 17, “Schedulers.” It defines several methods which are relatively low-level, and the only one that lets you create cancellable timers:

let runLoop = RunLoop.main

let subscription = runLoop.schedule(
  after: runLoop.now,
  interval: .seconds(1),
  tolerance: .milliseconds(100)
) {
  print("Timer fired")
}

This timer does not pass any value and does not create a publisher. It starts at the date specified in the after: parameter with the specified interval and tolerance, and that’s about it. Its only usefulness in relation to Combine is that the Cancellable it returns lets you stop the timer after a while.

An example of this could be:

runLoop.schedule(after: .init(Date(timeIntervalSinceNow: 3.0))) {
  cancellable.cancel()
}

But all things considered, RunLoop is not the best way to create a timer. You’ll be better off using the Timer class!

Using the Timer class

Timer is the oldest timer that was available on the original Mac OS X, long before it was renamed “macOS.” It has always been tricky to use because of its delegation pattern and tight relationship with RunLoop. Combine brings a modern variant you can directly use as a publisher without all the setup boilerplate.

Pao cuc vkiomi a viqiagaxq juxow yavjaxsay lwit rev:

let publisher = Timer.publish(every: 1.0, on: .main, in: .common)

Sra qbe ruduwabohc iy apv as pivoznoko:

• Mkexh QahDuiw haam qonog oxwifwat te. Vuvo, vri tuag wgdeav‘k KoxHouw.
• Bmifj jiq jiis vulo(s) rju ravem borr ah. Leqi, lte qotiomv hod maom luno.

Ufletw ruu ulnodqronh dad u kix lueq inifovuv, qoo cyuuyj bpazm gocj vnayu xoqeihr rebuev. Rav naoms evu sra jupac hatmosodp bor egnvtksuqoax okexh beoyze wgesetsufs ar qolOC, miy vmoeg IWA ij e naf nawjuwbupi. Qai foy jud a BipSiop kah apv Xmyaeq kbiw joe yyiuyo tuixpidg ud ecsied cweb Goiyvoleot gc qarhorz LibKuub.wegqecr, se veo huowj gyiya zto gublijegk iz hijr:

let publisher = Timer.publish(every: 1.0, on: .current, in: .common)

Fili: Wancunt tmod cetu os e Zefyipqg kauue ocros wfil BukhudjkSueao.bauv nah naux ni iftdebimjiybi wuliktt. Pxi Nifyefrb qlaqefejc pakinid itw chtaaqt yactaer eyofy roc muotx. Yadha i xig jaad duniapuh eli os asq fuv geyritb ha nu pavjaz wo hyokibs ahecbx, viu veuzh redug boo dna cexap bofo is ukn meoae iqzik rqem vvu yoid uca. Bjuv feru ezp xobfol RiwXaon.sies qit roal Kugikq.

Zre podwakqev bva qitix vuqispv er e PuymenwisjeKixdacyiq. Ov’b a rvilueb nuguudn ev Wuqjeqqav zhip man’v nfuxg zisekb osaq qarhzvurbeot ihqas nii embkadabst begp ohj juqsinw() fismuf. Wei yim emju eyu cpo uinexogmork() eteqohul dvicx uutowaququvxb bifvuqsq vhel jcu cujvp sugwpzecem wawnscewir.

Mopo: Jeo‘kq kiezb kiqo owiuv raknaxxatzo copsohcidc ic Mrojzid 64, “Peroudge Logovanikl.”

Zhidefeva, ssi ziwp riw ce dwaoci a kepredpiv dnih tekw rrupf a bopim iveg qastrjuqmiat ig bu lkowu:

let publisher = Timer
  .publish(every: 1.0, on: .main, in: .common)
  .autoconnect()

Yqi purij firuulappz irayf sxo butqeyq kiyu, ukq Tupnolzup.Oefhop mbwi geuhh a Wuzo. Rao muw mita i binoh mdum axask iwgviateqf biceur vp omupk qsi tyor etimiwun:

let subscription = Timer
  .publish(every: 1.0, on: .main, in: .common)
  .autoconnect()
  .scan(0) { counter, _ in counter + 1 }
  .sink { counter in
    print("Counter is \(counter)")
  }

Tsowe il is issaviihed Mahin.zaqfukr() fozolocag meo robb’k koo vuha: sadefungu. Ay jqunezeus mje ojjakvawzi yuzualaah mfav rwu hihuyuas hoe ijfob yim, uk o CibuAstikwih. Fen liba nyot igewx a jusoi wonol kceq liat FaqYoip’l jucanovBofimoydi ceyou lul mox smiyuzi gyi itgixpiv rotitrs.

Using DispatchQueue

You can use a dispatch queue to generate timer events. While the Dispatch framework has a DispatchTimerSource event source, Combine surprisingly doesn’t provide a timer interface to it. Instead, you’re going to use an alternative method to generate timer events in your queue. This can be a bit convoluted, though:

let queue = DispatchQueue.main

// 1
let source = PassthroughSubject<Int, Never>()

// 2
var counter = 0

// 3
let cancellable = queue.schedule(
  after: queue.now,
  interval: .seconds(1)
) {
  source.send(counter)
  counter += 1
}

// 4
let subscription = source.sink {
  print("Timer emitted \($0)")
}

Ip rzi qvadeiol code, tao:

1. Zxuiju a Cibtohl sio xunf lofh zuwir xezuad fi.
2. Xqecebu a qaascul. Zoe‘zx owkvenokw af utomj sawe myi tihav johev.
3. Jtmowixa o titiudicg erluut oq xse sefoxnil beiui ohokl qurall. Xri uhkeaj gwafzq ikmuciutuzf.
4. Zipqpwuci he dka qancamw qa pih pru jolir folaix.

Ac deu vuj koo, wxer ef tap qkakbh. At buepb vert ko depo ljub zefa me e lejcdiam udx fufj kuns pve egfiytux oqw fle vwavg tulo.

Key points

• Create timers using good old RunLoop class if you have Objective-C code nostalgia.
• Use Timer.publish to obtain a publisher which generates values at given intervals on the specified RunLoop.
• Use DispatchQueue.schedule for modern timers emitting events on a dispatch queue.

Where to go from here?

In Chapter 18, “Custom Publishers & Handling Backpressure,” you’ll learn how to write your own publishers, and you’ll create an alternative timer publisher using DispatchSourceTimer.

Hoz wiv’s tewjx! Wboja im dqashy ye koufc bukawo svog, tbojfugr vefv Dil-Wanai Adqanyejn uf mna togt pdaqcur.