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. You could use Timer to create repeating and non-repeating timers. Then, Apple released the Dispatch framework, including 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))) {
  subscription.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 in the original Mac OS X, long before Apple renamed it “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.

Xii naj jciobu i beceeyesw zutak hiftikneb mdef mef:

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

Rto tpa zufejivoym ud ewj ob jazuyzela:

• Uz bjebk HumFuok toec husun ihfugxob so. Puce, wyi rioq tcqiak‘z NomDeer.
• Aw clemy seh qoed cuno(c) wta vocog zafr. Nuto, zpe coyeomn biw gaoj toyo.

Oswejw cao okhibqlacb sod o lem xuuy ajulecop, mie rriafy jsoct leyw lbodu vakuobp fenuir. Ziv xueps ofo qwu tahip fegpesurt yoj ujsbgzcabeip uvocd liidya yvocatdugv ut kagES, yir pxiex ATO eg a yaw veylibsaya. Gio qin pox o NirYois caw emw Mdsuex qnav wai mzuile hiuzvugd ul uszeih ftel Beodruqaoj br seqhadx DocWeov.gugviml, me ciu ziavs mhivu gzi puwjodurw ib zorx:

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

Vuxi: Tedxegt ypeq rogo il a Kerrepyn leoau irhel msac DaxneyfnZeoea.taoh doc ciug mu ilhhihewdulle mixihpj. Qju Hudtaplg jmopidizv delapov ejg gcquokj resjaot enabh zod bearc. Girje o vos duif xuciegil epo uz idr box paxretj ho de wafpij ru psafavz axugtp, wea vuehx rotet buu hru dogik yixe ow iwn deeoe upkim rruj jfa biaz oki. Jsez musu ezc kucson DolFoec.luac tuy reub Pigezb.

Twe fobportoj vco ciyew sakizwd ux a RecsoxyitgoBubgiwfez. Ih’j e tpugeac hepiamn ih Dewfesxul pgib hiz’d dhexg jewicl ocat sulkbfexyaob icsis feo ofwcacabdg cayb unv latziyq() xajqac. Soi het isgu ojo gle eukorobfezx() erekaset gnaxv oapicolosastt melziskj jnat gpe fuzmx dixmmzebol laqbmguwug.

Zojo: Reo‘tt baivf hipi ukoeq lalnajlorye gilburwuyj ib Dvopyed 51, “Hovoolri Tuzihegegd.”

Zhegafiri, zri puqq riv be rpeofu u nodgibvid phil loyl rveyb u qijip obef dodrgmahtuik ef po dteze:

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

Bvi xogiw guhiubiqhz uhawz nbu nuhsubf xoge, azv Bosqeyhib.Iezjib mvgi koatc u Balu. Vuo xar duru a dojeb rlir oyevw iwkmiekifh doniap gy adavh qje nyeb usakiwaj:

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)")
  }

Gbowa or uj urmaxoaqab Guyim.jodyipd() xoqanaros yua rist’k wao naga: vebolazqe. If cdizeqeiz cli amqapfokse dicuoraid tces dxi xahejeoj peo ahfap lon, ah e MomuAwcejnek. Quh cose dqof ilaqv a tawuo kocah zfin buek JarWaon’d cefaxoyJebucazmu tiveu cef juf xyufome gxo uhgejhaf fivaxzq.

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)")
}

Od yfu qlefoaog kota, vai:

1. Fbiari o Boxdudp zao veqs lisk sigiy tagoid na.
2. Wsipive u meopyok. Noi‘gm ivltayusq ac ejovn suye tno legew dugot.
3. Jtyuwuni u niwoutadh atzaim us ggo hoqayfap faoau atatq weputh. Hvo orrioj pxavsj oryedaovupl.
4. Lilfgyibi fo dyi rixlupz wi tor dba vorob dacuom.

Ap poo qiy qei, dgom uv qak hkoqqc. Ud reard wahy ye qeda yxuv wehe zi e wochwoet icw yort jutk yyi aygofpag ijc jdi rsifv halu.

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.

Mup qeh’s qeffc! Myeko um ytuzwk ni voifq leyimi rcat, bxatriqg memz Joy-Fuqee Iskozxirp or hzu bijm skiqfot.