https://www.raywenderlich.com/5370-grand-central-dispatch-tutorial-for-swift-4-part-1-2

ez a swift sorozat párhuzamosságának folytatása. Lásd az 1. és 2. részt az alapok megértéséhez

ebben a részben a következő témákkal foglalkozunk

  1. mi a műveletek és az Életállapotok
  2. Blokk létrehozása, NSInvocationOperation és egyéni műveletek a feladatok futtatásához aszinkron
  3. hogyan lehet törölni a műveleteket
  4. mi a műveleti sorok
  5. műveletek hozzáadása a műveleti várólistákhoz
  6. hogyan hozzunk létre függőségeket a műveletek között
  7. a műveleti várólisták előnyei a GCD-vel szemben
  8. küldőcsoport megvalósítása műveleti várólisták használatával

a műveletek egy objektum-orientált módszer az aszinkron módon végrehajtani kívánt munka beágyazására. A műveleteket úgy tervezték, hogy vagy egy műveleti várólistával együtt, vagy önmagukban használják

egy műveleti objektum az Operation or NSOperation osztály egy példánya (a Foundation framework-ben), amelyet az alkalmazás által végrehajtani kívánt munka beágyazására használ.

maga a Műveleti Osztály egy absztrakt alaposztály, amelyet alosztályba kell sorolni minden hasznos munka elvégzéséhez. Annak ellenére, hogy elvont, ez az osztály jelentős mennyiségű infrastruktúrát biztosít a saját alosztályaiban elvégzendő munka mennyiségének minimalizálása érdekében. Ezenkívül az alapítványi keretrendszer két konkrét alosztályt biztosít,amelyeket a meglévő kóddal együtt használhat.

műveletek állapota

egy műveletnek van egy állapotgépe, amely az életciklusát képviseli. Számos lehetséges állapot fordul elő az életciklus különböző részein:

  • amikor instantiated volt, átáll a isReady állapotba.
  • amikor a start metódust hívtuk meg, az isExecuting állapotba kerül.
  • amikor a feladat finished, akkor mozog isFinished
  • amikor a feladat folyamatban van , és hívja cancel, akkor átmenet a isCancelled állapotban, mielőtt a isFinished állapot

vannak elsősorban három módon lehet létrehozni műveletek

BlockOperation (konkrét osztály)

egy osztály, amelyet as-ként használ, egy vagy több blokkobjektum egyidejű végrehajtására szolgál. Mivel egynél több blokkot is képes végrehajtani, a blokkműveleti objektum egy csoport szemantikával működik; a művelet csak akkor tekinthető befejezettnek, ha az összes társított blokk végrehajtása befejeződött.. A blokk műveletben kihasználhatja a műveleti függőségeket, KVO-t, értesítéseket és törlést .

az 1.ábrán látható módon végrehajtottuk ezt a kódot asyncami azt jelenti, hogy azonnal visszatér, de a rossz hír az, hogy blokkolja a fő szálat, mivel a operation.start() — et a fő szálon hívták meg

a műveleti objektumok alapértelmezés szerint szinkron módon hajtanak végre-vagyis a start metódust meghívó szálban hajtják végre.

ábra 1

mi a fene szinkron módon, és végre egy vagy több blokk objektumok egyidejűleg.

amint az 1.0.1 ábrán látható, amint láthatja a Blokkművelethez hozzáadott feladatokat/blokkokat egyidejűleg, de a blokk futása szinkron módon azt jelenti, hogy blokkolta azt a szálat, amelynél a startot hívják, esetünkben ez a fő szál

1.0 ábra.1

amint az ábrán látható ábra 1.0.2, mivel hívjuk start módszer más szál, akkor blokkolja, hogy a szál

ábra 1.0.2

amint az ábrán látható ábra 1.0.3, felvehetjük befejezése blokk is, amely hívja, ha az összes egyidejű blokk kerül végrehajtásra

ábra 1.0.3

futtassa a Blokkműveletet egyidejűleg

az 1.ábrán látható módon.1 mivel a start() metódust egy háttérszálon hívjuk, a feladatot a szálban hajtja végre. Van egy jó módja annak, hogy ezt a művelet sor, és látni fogjuk ezt később.

ábra 1.1

Nsinvocationoperation (konkrét osztály)

egy osztály, amelyet as-is-ként használ, hogy műveleti objektumot hozzon létre egy objektum és az alkalmazás választója alapján.

az objective C-ben létrehozhatunk NSInvocationOperation – et, miközben a Swift-ben nem érhető el.

https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationObjects/OperationObjects.html#//apple_ref/doc/uid/TP40008091-CH101-SW6

3. Egyéni műveletek

alosztály Operation teljes ellenőrzést biztosít a saját műveleteinek végrehajtása felett, beleértve a művelet végrehajtásának alapértelmezett módjának megváltoztatását és állapotának jelentését.

a 2.ábrán látható módon egyéni műveleteket hoztunk létre a Operation alaposztály alosztályával, és felülbíráltuk a main metódust. Amikor alosztályba helyezi a feladatot main módszer. Nem egyidejű egyéni műveletet hajtottunk végre, ebben az esetben blokkoltuk a fő szálat

ábra 2

ha manuálisan kívánja végrehajtani a műveleteket, de továbbra is aszinkron módon szeretné futtatni őket, akkor meg kell tennie a megfelelő lépéseket annak biztosítására, hogy azok megtörténjenek. Ezt úgy teheti meg, hogy a műveleti objektumot egyidejű műveletként határozza meg.

a 3. ábrán látható módon a következő lépéseket hajtottuk végre a feladat egyidejű végrehajtásához

  1. létrehozott alosztály MyConcurrentQueue. Typo: A név legyen MyConcurrentOperations
  2. hívás start() módszer fogja hívni main() módszer a háttér szál
  3. a fő módszer meghatároztuk a feladat, és egy dolog, hogy vegye figyelembe, Mi ellát megszünteti esetben is
  4. a hívás cancel az egyéni művelet átmenet a isCancelled állapot és megtörni a hurok, és amint az ábrán látható 3 akkor nyomtatni csak 39487 elemek

ábra 3

műveleti várólisták

  1. műveleti várólisták a Cocoa magas szintű absztrakciója a GCD-n
  2. használatával Műveleti sorok látni fogja a műveletek valódi erejét, ahelyett , hogy maga indítaná el a műveletet, átadja azt a műveleti sornak, majd kezeli az ütemezést és a végrehajtást.
  3. a műveleti várólisták objektum-orientált módszerek az aszinkron módon végrehajtani kívánt munka beágyazására.
  4. operations (feladatok/munka) hozzáadása a operation queue – hoz, és megvitattuk, hogyan hozhatunk létre műveleteket két módszerrel.

műveletek hozzáadása

a 4.ábrán látható módon két műveletet hoztunk létre (blokk használatával), és hozzáadtuk őket a műveleti sorba. Az Operation queue mindkét műveletet elindította valamilyen háttérszálon, majd végrehajtotta őket. Nem kell hívni start() metódust egyéni szálon. Amikor hozzáadunk műveletet a műveleti sorhoz, az azonnal fut, amint készen áll

ábra 4

amint az ábrán látható 5 mi csak végre feladat sorosan, vagy azt mondhatjuk, hogy végre soros sorban művelet segítségével sorok kérjük, olvassa el a részem 1 ha nem tudja, mi soros sorban beállításával maxConcurrentOperationCount = 1

maxConcurrentOperationCount →a sorban álló műveletek maximális száma, amelyek egyszerre hajthatók végre. Az alapértelmezett érték -1, ami azt jelenti, hogy hagyja, hogy a rendszer döntsön

ábra 5

a maxConcurrentOperationCount = 2 beállításával párhuzamos várólistát készítettünk, és most a feladatok egyidejűleg futnak az ábrán látható módon 6

ábra 6

műveleti függőségek

a 7. ábrán látható módon ismét létrehoztunk egy soros várólistát két feladat közötti függőségek hozzáadásával. Két blokkműveletet hoztunk létre, és azt mondjuk, hogy ne indítsa el az 1. feladatot, amíg a 2. feladat be nem fejeződik blockOperations1.addDependency(blockOperations2)

ábra 7

Dispatch Group Implementation Using Operations Queue

a 2. részben a GCD dispatch group funkciót használtuk egy szál blokkolására, amíg egy vagy több feladat befejeződik. Amint az a 8. ábrán látható, ugyanezt a viselkedést valósítottuk meg a műveleti várólisták használatával függőségek felhasználásával. Ez nagyon hasznos, ha nem tud előrelépni, amíg az összes megadott feladat be nem fejeződik.

a 8. ábrán látható módon három feladatunk van, és egyidejűleg akartunk futni, és amikor az összes feladat befejeződött, meg kell hívnunk valamilyen módszert annak jelzésére, hogy minden feladat befejeződött, és mit tettünk

  1. létrehozott egy műveleti várólistát
  2. létrehozott három blokk műveletet, amelyek feladatokat hajtanak végre
  3. létrehozott egy befejezési blokk műveletet (blockOperations4), amely akkor indul, amikor mindhárom feladat befejeződik
  4. made blockOperations4 függő blockOperations1, blockOperations2 és blockOperations3 ami azt jelenti, hogy a blockoperations4 akkor fog végrehajtani, amikor mindhárom feladat befejeződik
  5. waitUntilFinished → Blokkolja az aktuális szál végrehajtását, amíg a műveleti objektum befejezi a feladatát, mivel nem akarjuk blokkolni az aktuális szálat, amely a fő, hamis
  6. futtassa ezt a kódot, és a” minden művelet befejeződött ” kiírja, amikor a task1, task2 és task3 befejeződik

ábra 8

amint az A 9. ábrán látható, csak a waitUntilFinished = true. beállítással blokkoljuk a fő szálat, így a kérdés az, hogy mikor hasznos, és a következő részben megkapja a választ

ábra 9

amint az a 10. ábrán látható, végrehajtottunk egy feladó csoport viselkedését a műveleti sor használatával, függőségek használata nélkül, amit tettünk, a waitUntilFinished funkciót megfelelően használtuk . Ha háttérszálon van, blokkolhatja ezt a szálat, hogy elérje ezt a viselkedést. Szándékosan átkapcsoltam a háttérszálra a DispatchQueue.global().async metódus használatával, lásd az 1. részt, hogy megértsük ezt a kódot

azt mondtuk a műveletsornak, hogy futtassa az 1. feladatot, a 2. feladatot és a 3. feladatot a műveletsoron, és blokkolja az aktuális szálat, amíg ezek az egyidejű feladatok befejezik a végrehajtásukat

ábra 10

a műveleti várólisták előnyei a GCD-vel szemben

  1. a műveleti API támogatja a függőségeket. Nagyon könnyen létrehozhat összetett függőségeket a feladatok között, bár a GCD – ben elérheti, de sok munkát kell tennie.
  2. az NSOperation és NSOperationQueue osztályok számos olyan tulajdonsággal rendelkeznek, amelyek megfigyelhetők a KVO (Key Value Observing) használatával. Ez egy másik fontos előny, ha egy művelet vagy műveleti sor állapotát szeretné figyelemmel kísérni.
  3. a műveletek szüneteltethetők, folytathatók és törölhetők. Miután feladott egy feladatot a Grand Central Dispatch segítségével, már nincs ellenőrzése vagy betekintése a feladat végrehajtásába. Az NSOperation API rugalmasabb ebben a tekintetben, így a fejlesztő ellenőrzése alatt a művelet életciklusa
  4. az NSOperationQueue is hozzáteszi, számos előnnyel jár, hogy a mix. Megadhatja például az egyidejűleg futtatható sorban álló műveletek maximális számát. Ez megkönnyíti annak ellenőrzését, hogy hány művelet fut egyszerre, vagy soros műveleti sor létrehozását.

közelgő

a következő részben megvizsgáljuk az egyedi művelet létrehozásának tényleges felhasználási esetét

hasznos linkek

· https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationObjects/OperationObjects.html#//apple_ref/doc/uid/TP40008091-CH101-SW1

Vélemény, hozzászólás?

Az e-mail-címet nem tesszük közzé.