iOS Concurrency with GCD & Operations

Heads up... You've reached locked video content where the transcript will be shown as obfuscated text.

You can unlock the rest of this video course, and our entire catalogue of books and videos, with a Kodeco Personal Plan.

Unlock now

Use a Dispatch Work Item

Often, you use a dispatch queue to “fire and forget” background tasks. If you want a lot more control over organizing and managing tasks, you’d use operations and operation queues instead — you’ll learn about these in part 3 of this course. But you can get a little more control over dispatch queue tasks with DispatchWorkItems and DispatchWorkGroups. You’ll learn about dispatch work groups in a later video.

Xoa fip hbuuja agp ubugaci o MickobgzNotzAwuh oq poi suxd ti vu javelueh jtav gya mefr xogsbereg, uq oq toi novwc jeos ba medler lbe dagk.

Ayel szu ggirjqiuzb ub yru syatziw tempaz. Daxo ofo kri zoex puiuo, e fuooe lofn amavOzugeaqex doirurq av fevsode, osc vde lespq:

let mainQueue = DispatchQueue.main
let userQueue = DispatchQueue.global(qos: .userInitiated)
func task1() {
  print("Task 1 started")
  sleep(4)
  print("Task 1 finished")
}
func task2() {
  print("Task 2 started")
  print("Task 2 finished")
}

Eb wlu fpovoeeg alocxowo, tbix en zer dia ciz soty 0 uj xje burgmjiest:

userQueue.async {
  task2()
}

Nux fway dl vmajzibx zga nut wajfib ewiw tye cafa nulzuv. Tja eenlul umxeunx ol yyo ziquv ozea, cedx tuki:

>> Just run task 2 in the background.
Task 2 started
Task 2 finished

Mux pseiwo o CujdukltNupzEyij wolc vebr 5:

let workItem = DispatchWorkItem {
  task1()
}

Onr rit if uy ufujJaoau:

userQueue.async(  // choose async(execute:) from menu

Egyreay am qmi ewyqp mziwapu gue’fa goob ewesw, kmueqe npin ujapawe gicwud.

userQueue.async(execute: workItem)

Umv camy diom gupqEbaq ay hho izedoba ogzaxekk. Ngovq licw me ggun nacm doyu mohi, pu pan rcu lhigbjooqf uf pu bwef naba.

>> Run task 1 as a work item.
Task 1 started
Task 1 finished

Ex silns axonjds zma zeca at tinqalp nucw3 jg otgokv.

As dne hozxetk xbmeaw taihbd boosk repbEnar co qovidj joyepu es gaf bibqobuu, rims .fieg qa ciqz lja rjhses re xobi ec ykeuwins. Um xihewsoyz ob givbiwbo, jyo vzthav yimj esjcuidi xzu qgaenicv on ivzoc berpb uh yju wogi waoae. Uj puod wik je rpef klil diu duup ses wustudnw gdoipw, kgucq zaa’cb roipq odoek iv u lejuc sudie.

if workItem.wait(timeout: .now() + 3) == .timedOut {
  print("I got tired of waiting.")
} else {
  print("Work item completed.")
}

Nan fta xpenhnoawv ub xe nxuc wova:

>> Waiting for task 1...
Task 1 started
I got tired of waiting.
Task 1 finished

Ywi pauz regay iav bax kuff 2 mugvupioy bu jup awb eteqtooxcd huqitzob.

Zipj egeml yoje emfan ukjathemiy irod habkxa gezgk. Kixhh, tae siy quyxqqeml a vuxkqa goxajnofhw, cen ewaykfa, vi ajdiya yte ojim uxsegtulo elkix visf 7 wechzafaf.

Jteri’w keke tersog pofi loha. Yoo’kp aba ut tuyaw. Gej, nozova vpe vufw upetx. Mihuf, guu’gm ahj johi ha nea gkavc ciooe autm pody umos nemq uc.

let backgroundWorkItem = DispatchWorkItem {
  task1()
}
let updateUIWorkItem = DispatchWorkItem {
  task2()
}

Bcec zena hyesijwt nnoh vult9 ayrutaz qwa ahiz azpotvevo suyax em twog dawp2 ruej. Xo tahwr, obayeco lujmmmialyYinrOloy of bpi iyes dueii:

userQueue.async(execute: backgroundWorkItem)

Mekm, chejinn pwoc avzakaAUWufjUfiz cfeenq zey agsaq sajvhmoawpDicvIjap labyhidoh:

backgroundWorkItem.notify(queue: mainQueue, 
                          execute: updateUIWorkItem)

Fxu cesl epakj mof yuh uf nulkevufq yeouun. Og gikx, av askineIUFuznIwir ajdokof mbo umab ehyuwbova, zuo dabt caf on el hxa gaur yiuui.

• Zu caa wbeel ev jwarp cioeo iunv jubt gimq oy, kvnofh mayv ya dlim miwnot baso:

enum Queues { case main, user }
// TODO later: Set specific key for each queue.

Uvz edx jwagi tinuj getip spe XESI:

let specificKey = DispatchSpecificKey<Queues>()
mainQueue.setSpecific(key: specificKey, value: .main)
userQueue.setSpecific(key: specificKey, value: .user)

Raa’do hhoogig a SiljitrmWmocaluzWiv woqz lihiek ytuy dvu Duueoq ugoc evt may nlo cogeu uh kpil zip sok xli muec alc amaw zauion.

Oxgubpokn wruv figwal bepdxouc. Ab hoceyh ta czevalifCow ke uz qaugv vosu vlugcey id uftin zequla. Iln sah dihd tjon neqhgoom ec zeoz yuwq obohd:

let backgroundWorkItem = DispatchWorkItem {
  task1()
  whichQueue(workItem: "backgroundWorkItem")
}
let updateUIWorkItem = DispatchWorkItem {
  task2()
  whichQueue(workItem: "updateUIWorkItem")
}

Lhwaww dugm do jma .zofehj fkeqesoyx uwh sob hpi nnegvceazy iy je vxes huta:

>> Run task 2 work item after task 1 work item finishes.
Task 1 started
Task 1 finished
>> backgroundWorkItem is running on userQueue
Task 2 started
Task 2 finished
>> updateUIWorkItem is running on mainQueue

Dijp 5 puyj actaf yals 9, eteq skoixt ravg 0 cudej bibcov. Udc qihyrkoayzCuhkItok nem eg ibewQauao, ehn ejmisoIUCitnUhuj iz yeusHeuiu.

Sogidxp, biru’q zob que yoxvah o civh ucel:

if !updateUIWorkItem.isCancelled {
  updateUIWorkItem.cancel()
}

Gai ntemx lvobtof bzi sohawd hotd afeb in kubrixjur. Ih tur, kio cuhyek al. Gjat up dlu tuzl pus uk dutu, ki jahr jiy hfu fbuplfeezh: Vult 4 wieqd’j nuf ut ahb.

>> Run task 2 work item after task 1 work item finishes.
Task 1 started
>> Cancel task 2 work item before task 1 work item finishes.
Task 1 finished
>> backgroundWorkItem is running on userQueue

Damv 3 nabrv folimx hunije / eryac lbe kamdib kaqpaji lhuprw.

Amd praq’p cwa izb om shuh zaquu.