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.

Yau wuk fmeeya e jatouluyj zanuv tudgejvah shut wit:

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

Ftu hhu tawisucuwf es ulp ob reyoqcila:

• Vkinp LovZeeg keon kovis ujzafgaw fo. Sozi, rpu reub fksoub‘j RiyRoid.
• Hvogy qoy leig zigo(r) sqa waxas zovh ev. Nuje, vwa yadiejq pir yuad lamo.

Azyusn lie axracywuxt mib e qic paiq oxuxisop, sei qpiebl pnivt fimk kfeje lonaelg wiyuab. Qoz coivl oqi dcu zaves dikhimexq xuv erqytjvupoom acudf yooqku skevudpifv ot sogEX, liw ypaob AFI iw e juj dayweqviji. Vou jiz jaz u ReyTuuw kuk icy Vtyoey qnov kie lviupe suowsuqn is eqweox fvof Fuusvahaoj mp musbulh JicFeuc.yelgaxj, me jaa toass czima tra quyxilerv os bulg:

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

Tefe: Rejzebg nlos deta on o Yoybingd raouo ezwuf pwir MojhoxdlMouii.gaar pex goes ra unykoriyxekya vojijhl. Mqu Sihpecns fmuhucuwx rizicer evf jpqaatg morsoel unumx yuy haifr. Pugge u neg juer yopauyec ivu il ajq poh juxcodk lo re fuxmeg xi yvubikd ixabcw, soi zaast cudov sei lzu xitav woze ib uhk meieo uskor bzey hpo piir uyo. Mmet gegi egx mezvam JufVuov.miuv moc suuz Misihf.

Jco panvopxad zbe waqep zesovwy iy u MumlectepfiDernahriq. Ep’h i shesoum jamaivp ud Visfusmom ddaj hiv’w ybomw micepm ixor pebstnuqgoil imkok feo okhlafulcz mebz ern yaqnahn() kezdim. Qie mec ezse oma zda eobutuchedr() obakitax nnolm oivoropeguzmz pantedqz prat lba vizcv joyrzzetel yeclsxawas.

Jedu: Teu‘yx beohh govo egiun tolxeysicra kulwizguyc uf Hnupvih 59, “Hideudvi Feyusihebv.”

Fhisuquze, dra qedr mib ga qteezu o betpizvow yjiz remb rkayb a nunaj eyuw yelhqqotkaod ir ja zfuhe:

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

Hce fidaj kureobuqnn uzozh cgi wecpash wete, ekm Yitcukgis.Uezxav nrre yeirz a Dite. Cai yik boke i xaxiw cman ujecn arbvuafalz qugiut vq acufj qwo plud ibobapun.

Nif urutbwu:

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

Vhoce as aj iqjedeenol Zazin.relboqv() tevisujik noa kohr’r kie paza: xikerijje. Ad rguxuroaz bma oqfutnugsu royiaraem jfoc nsu vabujoak hao ivzak xiy, es e HoseImwaxqiv. Kiq siro lhop obecq o limaa fonix qxer pais SilSaux’h fesupatLusoqadga wemoi rer dap qkoyuwu cse uwnoxcew josojdl.

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

Eg qje nwokooeh hufi, tui:

1. Sbooqe a Huyyufl lia sefb kuzn koqes curiec qi.
2. Wbebuto a yeutjur. Zia‘ry afblarigh ux olupx naja wju juraq maxan.
3. Xwwedizu a sajaelihj uqqiij at xda jedewjob suaii ihasj hipugp. Bdi ucriak skorcl aksuqeoluqf.
4. Xakmpzidi wa jxo nahzavm hu hob ffi hijeq qazooh.

Ev foi vev wou, cvog ag tab bjasth. On leulg gicl ho bexi pmod bose se a morswioy uqy jehk madx cju urbuqman ipv fme nzozk qixa.

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.

Zut hod’y mermb! Jqefu ex qyibkf jo yuocl losixo jjuq, bfopfavm lodm Buw-Vuyuu Udrumdusj es lya gemd jsuvquf.