Korutiinid põhinevad generaatorite kontseptsioonil, kus funktsioon võib anda väärtusi ja hiljem täitmist jätkata. Korutiinid on võimas tööriist asünkroonsete toimingute haldamiseks ja võivad oluliselt parandada teie koodi üldist kvaliteeti.
Korutiinide kasutusalad
Korutiinid on kaasaegses programmeerimises vajalikud mitmel põhjusel, eriti sellistes keeltes nagu C++. Siin on mõned peamised põhjused, miks korutiin on kasulik:
Korutiinid pakuvad elegantset lahendust asünkroonseks programmeerimiseks. Need võimaldavad luua järjestikuse ja blokeeriva koodi, mida on lihtsam arutleda ja mõista. Korutiinid võivad nende täitmise teatud punktides peatada ilma lõime blokeerimata, võimaldades paralleelselt toimida ka muudel ülesannetel. Tänu sellele saab süsteemi ressursse tõhusamalt kasutada ja reageerimisvõime suureneb rakendustes, mis hõlmavad I/O toiminguid või ootavad väliseid sündmusi.
Need võivad muuta koodi hõlpsamini mõistetavaks ja hooldatavaks. Keerukate tagasihelistamisahelate või olekumasinate kõrvaldamisega võimaldavad korutiinid koodi kirjutada lineaarsemas ja järjestikuses stiilis. See parandab koodi korraldust, vähendab pesastamist ja muudab loogika hõlpsasti arusaadavaks.
Korutiinid pakuvad struktureeritud viisi samaaegsuse ja paralleelsuse käsitlemiseks. Need võimaldavad teil väljendada keerulisi koordineerimismustreid ja asünkroonseid töövooge, kasutades intuitiivsemat süntaksit. Erinevalt traditsioonilistest keermestusmudelitest, kus lõimed võivad olla blokeeritud, võivad korutiinid vabastada süsteemi ressursse ja võimaldada tõhusat multitegumtööd.
Loome mõned näited, et demonstreerida korutiinide rakendamist C++-s.
Näide 1: Põhilised korutiinid
Korrutiinide põhinäide on toodud järgmises.
#include
#include
struktuur See Corout {
struktuur lubaduse_tüüp {
ThisCorout get_return_object ( ) { tagasi { } ; }
std :: peata_mitte kunagi esialgne_peatus ( ) { tagasi { } ; }
std :: peata_mitte kunagi lõplik_peatamine ( ) ei välja arvatud { tagasi { } ; }
tühine käsitlemata_erand ( ) { }
tühine return_void ( ) { }
} ;
bool await_ready ( ) { tagasi vale ; }
tühine await_suspend ( std :: coroutine_handle <> h ) { }
tühine oota_resume ( ) { std :: cout << 'Korutiin jätkub.' << std :: endl ; }
} ;
See Corout foo ( ) {
std :: cout << 'Korutiin on alanud.' << std :: endl ;
co_await std :: peata_alati { } ;
co_return ;
}
int peamine ( ) {
auto kr = foo ( ) ;
std :: cout << 'Korutiin on loodud.' << std :: endl ;
kr. oota_resume ( ) ;
std :: cout << 'Korutiin lõppes.' << std :: endl ;
tagasi 0 ;
}
Vaatame läbi eelnevalt esitatud koodi ja selgitame seda üksikasjalikult:
Pärast vajalike päisefailide lisamist määratleme korutiini esindava struktuuri ThisCorout. Sees 'ThisCorout' on määratletud teine struktuur, mis on 'promise_type', mis käsitleb korutiini lubadust. See struktuur pakub erinevaid funktsioone, mida korutiinimasinad nõuavad.
Sulgudes kasutame funktsiooni get_return_object(). See tagastab korutiiniobjekti enda. Sel juhul tagastab see tühja objekti 'ThisCorout'. Seejärel käivitatakse funktsioon origin_suspend(), mis määrab käitumise korutiini esmakordsel käivitamisel. Std::suspend_never tähendab, et korutiini ei tohiks esialgu peatada.
Pärast seda on meil funktsioon final_suspend(), mis määrab käitumise, kui korutiin on lõppemas. Std::suspend_never tähendab, et korutiini ei tohiks enne selle lõpetamist peatada.
Kui korotiin teeb erandi, käivitatakse meetod unhandled_exception(). Selles näites on see tühi funktsioon, kuid saate vajaduse korral erandeid käsitleda. Kui korotiin lõpeb väärtust andmata, käivitatakse meetod return_void(). Sel juhul on see ka tühi funktsioon.
Samuti määratleme „ThisCoroutis“ kolm liikmefunktsiooni. Funktsioon await_ready() kutsutakse välja kontrollimaks, kas korutiin on täitmise jätkamiseks valmis. Selles näites tagastab see alati vale, mis näitab, et korotiin ei ole kohe valmis jätkama. Kui korutiini peatatakse, kutsutakse välja meetod await_suspend(). Siin on see tühi funktsioon, mis tähendab, et peatamine pole vajalik. Programm kutsub await_resume(), kui korutiini jätkatakse pärast peatamist. See lihtsalt väljastab sõnumi, mis teatab, et korutiini on jätkatud.
Koodi järgmised read määratlevad foo() korutiinifunktsiooni. Foo() sees prindime alustuseks sõnumi, mis ütleb, et korutiin on alanud. Seejärel kasutatakse korutiini peatamiseks käsku co_await std::suspend_always{}, mis näitab, et seda saab hiljem jätkata. Co_return lauset kasutatakse korutiini lõpetamiseks ilma väärtust tagastamata.
Funktsioonis main() konstrueerime objekti 'cr' tüüpi 'ThisCorout', kutsudes välja foo(). See loob ja käivitab korutiini. Seejärel prinditakse teade, et korutiin on loodud. Järgmisena kutsume korutiiniobjekti 'cr' await_resume() selle täitmise jätkamiseks. Faili await_resume() sisse prinditakse teade „Korutiin jätkub”. Lõpuks kuvame sõnumi, mis teatab, et korutiin on lõpetatud enne programmi lõpetamist.
Selle programmi käivitamisel on väljund järgmine:
Näide 2: Korutiin parameetrite ja tootlikkusega
Nüüd pakume selle illustratsiooni jaoks koodi, mis demonstreerib korutiinide kasutamist parameetritega ja C++-s, et luua generaatorilaadne käitumine numbrijada loomiseks.
#include#include
#include
struktuur UUS Korutiin {
struktuur p_tüüp {
std :: vektor < int > väärtused ;
NEWCoroutine get_return_object ( ) { tagasi { } ; }
std :: peata_alati esialgne_peatus ( ) { tagasi { } ; }
std :: peata_alati lõplik_peatamine ( ) ei välja arvatud { tagasi { } ; }
tühine käsitlemata_erand ( ) { }
tühine return_void ( ) { }
std :: peata_alati saagi_väärtus ( int väärtus ) {
väärtused. lükka tagasi ( väärtus ) ;
tagasi { } ;
}
} ;
std :: vektor < int > väärtused ;
struktuur iteraator {
std :: coroutine_handle <> koori_käepide ;
bool operaator != ( konst iteraator & muud ) konst { tagasi koori_käepide != muud. koori_käepide ; }
iteraator & operaator ++ ( ) { koori_käepide. Jätka ( ) ; tagasi * see ; }
int operaator * ( ) konst { tagasi koori_käepide. lubadus ( ) . väärtused [ 0 ] ; }
} ;
iteraator algab ( ) { tagasi iteraator { std :: coroutine_handle < p_tüüp >:: from_promise ( lubadus ( ) ) } ; }
iteraatori lõpp ( ) { tagasi iteraator { nullptr } ; }
std :: coroutine_handle < p_tüüp > lubadus ( ) { tagasi
std :: coroutine_handle < p_tüüp >:: from_promise ( * see ) ; }
} ;
NEWCoroutine genereeribNumbreid ( ) {
kaassaagis 5 ;
kaassaagis 6 ;
kaassaagis 7 ;
}
int peamine ( ) {
UUSCoroutine nc = genereeridaNumbreid ( ) ;
jaoks ( int väärtus : nc ) {
std :: cout << väärtus << ' ' ;
}
std :: cout << std :: endl ;
tagasi 0 ;
}
Eelmises koodis esindab NEWCoroutine struktuur korutiinipõhist generaatorit. See sisaldab pesastatud struktuuri 'p_type', mis toimib korutiini lubaduse tüübina. Struktuur p_type määratleb funktsioonid, mida korutiinimasinad nõuavad, nagu get_return_object(), origin_suspend(), final_suspend(), unhandled_exception() ja return_void(). Struktuur p_type sisaldab ka funktsiooni result_value(int value), mida kasutatakse korutiini väärtuste saamiseks. See lisab antud väärtuse väärtuste vektorile.
Struktuur NEWCoroutine sisaldab std::vector
Kasutame funktsiooni begin() iteraatori loomiseks korutiini alguses, hankides p_type lubadusest koodi coro_handle. Funktsioon end() loob iteraatori, mis tähistab korutiini lõppu ja on konstrueeritud nullptr coro_handle'iga. Pärast seda kasutatakse lubaduse tüübi tagastamiseks funktsiooni lubadus (), luues lubaduse p_type põhjal käsu coroutine_handle. Funktsioon generateNumbers() on korutiin, mis annab kolm väärtust – 5, 6 ja 7 – kasutades märksõna co_yield.
Funktsioonis main() luuakse NEWCoroutine'i eksemplar nimega “nc”, kutsudes esile genereerimisnumbrid() korutiini. See lähtestab korutiini ja jäädvustab selle oleku. Vahemikupõhist 'for' tsüklit kasutatakse 'nc' väärtuste itereerimiseks ja iga väärtus prinditakse, mis eraldatakse tühikuga, kasutades std::cout.
Loodud väljund on järgmine:
Järeldus
See artikkel demonstreerib korutiinide kasutamist C++-s. Arutasime kahte näidet. Esimesel illustratsioonil luuakse põhikorutiin C++ programmis, kasutades korutiini funktsioone. Samal ajal kui teine demonstratsioon viidi läbi, kasutades parameetritega korutiine ja andes järele generaatorilaadse käitumise genereerimiseks numbrijada loomiseks.