1. Perkenalan
Orang yang telah belajar terbang tidak akan merangkak lagi. Tetapi juga tidak boleh ada kesombongan terhadap seseorang yang pada prinsipnya "tidak bisa terbang". Keduanya cukup normal. Keduanya dihormati dan terhormat. Bagi seseorang, ini seperti memilih profesi: Anda, secara konvensional, adalah seorang pilot atau pengemudi. Untuk hewan yang sama, itu sama - Anda adalah elang atau serigala, mis. Entah Anda terbang atau Anda lari (lari) Tetapi hanya seseorang dalam konsep, kategori, sikap dan pemikirannya yang memberkahi karakter dengan karakteristik dan mengembangkan sikapnya terhadap mereka. Benar, dengan nuansa. Jadi, tidak, mungkin, itu lebih terhormat dan romantis daripada profesi pilot, tapi cobalah untuk meyakinkan pengemudi truk atau perancang pesawat tentang ini ?! Dan di sini sulit untuk diperdebatkan: ada banyak astronot bahkan sekarang, dan masih belum ada Ratu kedua!
Kami adalah programmer. Mungkin dengan derajat yang berbeda-beda, tetapi beberapa - pasti. Maksud saya, kita berbeda dan kita juga bisa berpikir dengan cara yang berbeda. Pernyataan bahwa seorang programmer hanya berpikir secara konsisten sama sepihak, berbahaya dan bahkan menghujat, seperti fakta bahwa seseorang hanya berjalan. Dia terkadang - dan terbang. Beberapa, seperti pilot, melakukannya secara teratur, dan beberapa, seperti astronot, bahkan selama berbulan-bulan dan terus menerus. Ide pemikiran yang konsisten mengurangi kemampuan manusia. Pada suatu saat dan untuk sementara, Anda bahkan dapat mempercayainya, tetapi "tetap saja berputar" - ini adalah tentang fakta bahwa cepat atau lambat kehidupan akan membawa korban.
Asyncio dalam Python adalah kruk perangkat lunak yang meniru, secara kiasan, penerbangan dari pemikiran paralel yang salah. Semacam memantul dengan melambaikan tangan. Kelihatannya, terkadang, lucu dan kikuk. Meskipun dalam situasi tertentu ini juga merupakan jalan keluar: Anda bisa saja menyeberangi genangan air dan menjadi kotor, tetapi jika kekuatan memungkinkan, maka lebih baik melompati. Tapi mungkin programmernya kurang kuat?
Mari kita coba membuang "kruk perangkat lunak" yang dikenakan dan melambung di atas rutinitas perangkat lunak. Dan biarlah itu bukan lompatan, atau mungkin tidak terlalu tinggi dan panjang, tapi tetap saja, terutama dibandingkan dengan kruk, sebuah penerbangan. Lagi pula, suatu saat Mozhaisky Alexander Fedorovich (jangan bingung dengan Pengadilan Kota Mozhaisky di Wilayah Moskow;) atau Wright bersaudara yang sama mengatasi beberapa ratus meter di udara untuk pertama kalinya. Ya, dan pengujian pesawat modern dimulai dengan lari dan pemisahan jangka pendek dari landasan.
2. Contoh yang sangat sederhana dengan asyncio
Kami akan mulai dengan terbang dengan Python. Program penerbangannya sederhana. Ada pesawat (yang, bagaimanapun, dalam versi asli citra laba-laba, lihat [1] ) dengan nama di badan pesawat "Blog", "Berita", "Forum". Mereka lepas landas pada saat bersamaan. Setiap orang harus mengibarkan satu ruas jalan dalam waktu tertentu dan melempar, katakanlah, bendera dengan nomor ruas yang tercakup. Ini harus dilakukan tiga kali. Dan baru kemudian mendarat.
Dalam Python, model dari perilaku ini dideskripsikan dan kemudian disimulasikan oleh kode pada Listing 1.
Daftar 1. Kode Python untuk spider planes
import asyncio
import time
async def spider(site_name):
for page in range(1, 4):
await asyncio.sleep(1)
print(site_name, page)
spiders = [
asyncio.ensure_future(spider("Blog")),
asyncio.ensure_future(spider("News")),
asyncio.ensure_future(spider("Forum"))
]
start = time.time()
event_loop = asyncio.get_event_loop()
event_loop.run_until_complete(asyncio.gather(*spiders))
event_loop.close()
print("{:.2F}".format(time.time() - start))
Hasil simulasi untuk "penerbangan" semacam itu adalah sebagai berikut:
Blog 1
Berita 1
Forum 1
Blog 2
Berita 2
Forum 2
Blog 3
Berita 3
Forum 3
3.00
Mengapa hal ini dijelaskan secara detail dalam video [1]. Tapi kami orang-orang dengan imajinasi dan simultan (sesuai dengan skenario - asynchronous) penerbangan dari kami tiga "pesawat" tanpa menggunakan asyncio akan hadir dengan cara yang berbeda - atas dasar model otomatis. Sebagai contoh, Kode 2 menunjukkan kode untuk penundaan otomatis, analog dari penundaan async dari modul asyncio, diwakili oleh baris await asyncio.sleep (1) di Properti 1.
Kode 2. Kode penundaan otomatis dengan Python
import time
class PSleep:
def __init__(self, t, p_FSM): self.SetTime = t; self.nState = 0; self.bIfLoop = False; self.p_mainFSM = p_FSM
def x1(self): return time.time() - self.t0 <= self.SetTime
def y1(self): self.t0 = time.time()
def loop(self):
if (self.nState == 0): self.y1(); self.nState = 1
elif (self.nState == 1):
if (not self.x1()): self.nState = 4
Nilai penundaan dan penunjuk ke objek yang membuat objek penundaan dilewatkan melalui konstruktor kelas. Penunjuk diperlukan oleh fungsi kontrol proses, yang, setelah menghapus penundaan, akan melanjutkan proses induk, yang dihentikan saat dibuat.
Kode 3 menunjukkan mitra automaton ke bidang spider asinkron (lihat juga Daftar 1). Sangat mungkin bahwa ace pemrograman Python tidak akan memimpikan ini, bahkan dalam mimpi buruk! Kode sumber empat baris telah berkembang 15 kali! Bukankah ini alasan kekaguman terhadap kode Python pada umumnya dan asycio pada khususnya, atau setidaknya bukti keunggulan "teknologi coroutine" dibandingkan pemrograman otomat?
Kode 3. Kode untuk robot laba-laba dengan Python
# "" "Blog"
class PBSpider:
def __init__(self, name):
self.nState = 0; self.bIfLoop = True; self.site_name = name; self.page = 1;
self.p_mainFSM = b_sleep;
def x1(self): return self.page < 4
def y1(self):
self.bIfLoop = False; automaton.append(b_sleep);
b_sleep.p_mainFSM = blog
automaton[-1].bIfLoop = True;
automaton[-1].nState = 0
def y2(self): print(self.site_name, self.page)
def y3(self): self.page += 1
def y4(self): self.page = 1
def loop(self):
if (self.x1() and self.nState == 0): self.y1(); self.nState = 1
elif (not self.x1() and self.nState == 0): self.y1(); self.y4(); self.nState = 33
elif (self.nState == 1): self.y2(); self.y3(); self.nState = 0
# "" "News"
class PNSpider:
def __init__(self, name):
self.nState = 0; self.bIfLoop = True; self.site_name = name; self.page = 1;
self.p_mainFSM = n_sleep;
def x1(self): return self.page < 4
def y1(self):
self.bIfLoop = False; automaton.append(n_sleep);
n_sleep.p_mainFSM = news
automaton[-1].bIfLoop = True;
automaton[-1].nState = 0
def y2(self): print(self.site_name, self.page)
def y3(self): self.page += 1
def y4(self): self.page = 1
def loop(self):
if (self.x1() and self.nState == 0): self.y1(); self.nState = 1
elif (not self.x1() and self.nState == 0): self.y1(); self.y4(); self.nState = 33
elif (self.nState == 1): self.y2(); self.y3(); self.nState = 0
# "Forum"
class PFSpider:
def __init__(self, name):
self.nState = 0; self.bIfLoop = True; self.site_name = name; self.page = 1;
self.p_mainFSM = f_sleep;
def x1(self): return self.page < 4
def y1(self):
self.bIfLoop = False; automaton.append(f_sleep);
f_sleep.p_mainFSM = forum
automaton[-1].bIfLoop = True;
automaton[-1].nState = 0
def y2(self): print(self.site_name, self.page)
def y3(self): self.page += 1
def y4(self): self.page = 1
def loop(self):
if (self.x1() and self.nState == 0): self.y1(); self.nState = 1
elif (not self.x1() and self.nState == 0): self.y1(); self.y4(); self.nState = 33
elif (self.nState == 1): self.y2(); self.y3(); self.nState = 0
#
b_sleep = PSleep(1, 0)
n_sleep = PSleep(1, 0)
f_sleep = PSleep(1, 0)
# ""
blog = PBSpider("Blog")
news = PNSpider("News")
forum = PFSpider("Forum")
#
automaton = []
automaton.append(blog);
automaton.append(news);
automaton.append(forum);
start = time.time()
# ( event_loop)
while True:
ind = 0;
while True:
while ind < len(automaton):
if automaton[ind].nState == 4:
automaton[ind].p_mainFSM.bIfLoop = True
automaton.pop(ind)
ind -=1
elif automaton[ind].bIfLoop:
automaton[ind].loop()
elif automaton[ind].nState == 33:
print("{:.2F}".format(time.time() - start))
exit()
ind += 1
ind = 0
Dan berikut adalah hasil dari penerbangan otomatis:
Berita 1
Forum 1
Blog 1
Blog 2
Berita 2
Forum 2
Berita 3
Forum 3
Blog 3
3.00
Tapi - mari kita bahas. Peningkatan ukuran kode ini karena masalah dengan pointer di Python. Akibatnya, saya harus membuat kelas untuk setiap halaman, yang melipatgandakan kode. Oleh karena itu, lebih tepat untuk berbicara bukan tentang 15, tetapi tentang peningkatan volume lima kali lipat. Seorang "pilot Python" yang lebih terampil dalam pemrograman bahkan mungkin dapat menghilangkan kekurangan ini.
Tapi alasan utamanya masih belum ada petunjuk. Kode C ++ yang ditunjukkan di bawah ini, dengan kebebasan penuh untuk bekerja dengan pointer, memiliki lebih banyak baris per kelas. Alasannya adalah model komputasi yang digunakan, bahasa deskripsinya dan pendekatan untuk implementasi algoritma berdasarkan itu. Angka: Gambar 1 menunjukkan model pesawat laba-laba konvensional dalam bentuk diagram blok dan model senapan mesin. Anda dapat melihat bahwa secara lahiriah dan dalam kualitas, ini adalah model yang berbeda, meskipun memungkinkan transformasi yang setara. Automata memiliki status, tetapi diagram blok bahkan tidak memiliki jejaknya. Automata, menurut definisi, beroperasi dalam waktu diskrit, dan diagram blok bahkan tidak memimpikannya. Semua ini membebankan kewajiban tertentu pada implementasi model.
Tidak adanya konsep waktu diskrit adalah inti dari masalah model pemrograman diagram blok yang ada, yang, secara tegas, harus menyadari apa yang tidak dapat direalisasikan untuknya, yaitu. proses paralel. Ingatlah bahwa untuk automata, jaringan otomat, sebagai model proses paralel (serta asinkron), adalah keadaan alaminya.
Angka: 1. Model otomatis dan diagram blok dari bidang laba-laba
Tetapi bahkan pada tingkat proses yang terpisah, model memiliki perbedaan yang diproyeksikan ke bahasa dan implementasi model. Berdasarkan kualitas ini, para pembela untuk diagram blok yang konsisten telah menciptakan konstruksi bahasa yang, baik secara eksplisit maupun implisit, memungkinkan untuk menggambarkannya dengan sangat kompak. Ambil hal yang sama untuk loop atau setidaknya urutan eksekusi operator yang tersirat secara implisit (tindakan y1, y2, y3).
Untuk diagram alur, Anda dapat membuat daftar tindakan dalam satu kotak tanpa masalah dan ini tidak akan mengubah sifat urutan pekerjaannya. Jika robot menggantikan transisi di negara bagian s2, s3 dengan siklus di negara bagian s1, menandai busur dengan tindakan yang sama, maka arti dari algoritme akan berubah, karena akan memperkenalkan paralelisme pada pekerjaannya. Karena tindakan di atas harus dilakukan secara berurutan secara ketat, ini telah menentukan penampilan model otomat (lihat Gbr. 1). Otomat terbatas adalah model yang tidak mengizinkan "tautan ganda".
Kurangnya waktu diskrit dalam diagram blok adalah keuntungan mereka. Tetapi sekarang ini telah menjadi kelemahan utama mereka. Itu mempengaruhi, karena mungkin tidak tampak menghujat, dan cara berpikir. Bahasa sekuensial membenarkan pemikiran sekuensial pemrogram dengan menyangkal sesuatu yang lain - paralel. Inilah yang membenarkan konstruksi pemrograman asinkron yang ada, menghadirkan himpunan dan fungsionalitas operator dari paket asyncio yang sama. Dan justru pendekatan inilah yang memungkinkan pemrogram yang terbiasa dengan program sekuensial berubah menjadi asinkron (hampir paralel).
Tapi kembali ke topik artikel dan gambarnya. Kami menginginkan "pesawat" kami dan kami mendapatkannya! Penerbangan, atau, lebih tepatnya, hasil yang terlihat, agak berbeda dalam penampilan, tetapi sifatnya sama sekali tidak dapat dibedakan. Mereka dapat diinterpretasikan sedemikian rupa sehingga bendera dipilih dan dicatat dalam protokol dengan urutan yang berbeda, tetapi "pesawat" itu sendiri terbang sebagaimana mestinya, yaitu secara bersamaan dan sekaligus membuang benderanya. Dan dalam urutan apa mereka dicatat - kasusnya, seperti yang mereka katakan, adalah yang kesepuluh. Hal utama yang disadari dan dipenuhi: urutan dan waktu rilis mereka sesuai dengan program penerbangan
Kode bisa dipersingkat. Jadi, ternyata, Anda dapat membatasi diri Anda pada kode hanya satu kelas. Anda juga dapat menyembunyikan kode loop peristiwa. Jika, pada saat yang sama, dalam kode sumber, Anda membuka kode kompartemen mesin, yang tersembunyi di belakang asyncio dan menunggu operator, maka volume kode otomatis kemungkinan besar tidak akan terlalu menakutkan.
3. Tentang masalah penerapan automata dengan Python
Mari kita membahas lebih detail tentang masalah yang menyebabkan munculnya kode otomatis. Hal terakhir yang disembunyikan di sana sejauh ini terlihat mengerikan dibandingkan dengan kode sumbernya. Namun, mari kita perhatikan bahwa pesawat pertama Mozhaisky jauh dari serupa dengan "pengeringan" modern, dan mobil pertama tidak berbeda jauh lebih baik dari rekan-rekan modern mereka. Izinkan saya menekankan bahwa masalah kode otomat yang disajikan sebagian besar terkait dengan pemahaman saya saat ini tentang bahasa Python dan, mungkin, pada tingkat yang lebih rendah dengan kemampuan bahasa itu sendiri.
Kendati demikian, masalah pertama terkait dengan bahasa deskripsi model otomat. Dalam C ++ itu diselesaikan dengan menggunakan bahasa. Saya tidak melihat kemungkinan seperti itu di Python. Sayangnya, seperti yang terkadang mereka katakan sekarang, dari kata sama sekali. Oleh karena itu, metode penerapan automata berdasarkan operator kontrol bahasa if-elif-else diambil sebagai dasar. Selain itu, kami ingat bahwa di CPSU (a), selain automata itu sendiri, memori bayangan dan ruang otomat diperkenalkan untuk mengimplementasikan paralelisme sepenuhnya. Tanpa ini, kemungkinan pemrograman automata sangat terbatas dan dalam banyak hal lebih rendah.
Masalah selanjutnya yang telah kami sebutkan adalah petunjuk. Tidak ada masalah dengan mereka di C ++. Dalam kerangka CPSU (a), sesuai dengan paradigma OOP, kelas otomat dasar telah dibuat, dari mana kelas automata yang diterapkan dihasilkan, dan parameternya tidak hanya dapat berupa penunjuk, tetapi bahkan alamatnya. Semua ini memungkinkan untuk mendeskripsikan dan mengimplementasikan tugas apa pun yang mencakup banyak proses interaksi paralel secara sederhana, kompak, dan sangat efisien.
Berikut ini adalah kode kelas automata C ++ yang setara dengan contoh yang dipertimbangkan. Kode penundaan dalam Kode 4 setara dengan baris menunggu asyncio.sleep (1) di Properti 1. Dalam bentuk grafik, ini sesuai dengan model otomat FAwaitSleep pada Gambar 1. 1. Otomat seperti itu dan hanya semacam itu yang dapat dianggap asinkron dan tidak akan memperlambat aliran komputasi. FSleep dalam gambar yang sama sesuai dengan operator sleep () biasa. Ini lebih sederhana, tetapi dijamin akan menghancurkan model waktu diskrit karena tindakan y1 menyebabkan penundaan berurutan yang biasa. Dan ini tidak lagi berguna untuk apapun.
Kode 4. Kode penundaan Asynchronous
// ( )
#include "lfsaappl.h"
#include <QTime>
class FAwaitSleep :
public LFsaAppl
{
public:
FAwaitSleep(int n);
protected:
int x1();
QTime time;
int nAwaitSleep;
};
#include "stdafx.h"
#include "FAwaitSleep.h"
static LArc TBL_AwaitSleep[] = {
LArc("s1", "s1","x1", "--"), //
LArc("s1", "00","^x1", "--"), //
LArc()
};
FAwaitSleep::FAwaitSleep(int n):
LFsaAppl(TBL_AwaitSleep, "FAwaitSleep")
{
nAwaitSleep = n; time.start();
}
int FAwaitSleep::x1() { return time.elapsed() < nAwaitSleep; }
Kode C ++ untuk spider-plane ditunjukkan pada Listing 5. Kode ini jauh lebih memadai untuk modelnya daripada diagram blok dari kode Python. Apalagi jika kita membandingkan tabel transisi automaton dan tampilan grafik automaton. Mereka hanyalah bentuk yang berbeda untuk menggambarkan konsep abstrak yang sama - robot. Ini juga menunjukkan bagaimana pointer ke kelas induk diteruskan saat membuat penundaan (lihat panggilan ke metode FCall dalam aktivitas y1)
Kode 5. Kode untuk spider plane yang mensimulasikan membaca halaman situs
// "".
#include "lfsaappl.h"
class FAwaitSleep;
class FSpider :
public LFsaAppl
{
public:
LFsaAppl* Create(CVarFSA *pCVF) { Q_UNUSED(pCVF)return new FSpider(nameFsa); }
bool FCreationOfLinksForVariables() override;
FSpider(string strNam);
virtual ~FSpider(void);
CVar *pVarStrSiteName; //
FAwaitSleep *pFAwaitSleep{nullptr};
protected:
int x1(); void y1(); void y2(); void y3(); void y4();
int page{1};
};
#include "stdafx.h"
#include "FSpider.h"
#include "FSleep.h"
#include "FAwaitSleep.h"
#include <QDebug>
static LArc TBL_Spider[] = {
LArc("st","s1","--","--"),
LArc("s1","s2","x1","y1"), // x1- <. ; y1-;
LArc("s2","s3","--","y2"), // y2- ;
LArc("s3","s1","--","y3"), // y3-
LArc("s1","st","^x1","y4"), // y4-
LArc()
};
FSpider::FSpider(string strNam):
LFsaAppl(TBL_Spider, strNam)
{ }
FSpider::~FSpider(void) { if (pFAwaitSleep) delete pFAwaitSleep; }
bool FSpider::FCreationOfLinksForVariables() {
pVarStrSiteName = CreateLocVar("strSiteName", CLocVar::vtString, "name of site");
return true;
}
// ?
int FSpider::x1() { return page < 4; }
// create delay - pure sleep (synchronous function) or await sleep (asynchronous function)
void FSpider::y1() {
//sleep(1000);
// await sleep (asynchronous function)
if (pFAwaitSleep) delete pFAwaitSleep;
pFAwaitSleep = new FAwaitSleep(1000);
pFAwaitSleep->FCall(this);
}
void FSpider::y2() {
#ifdef QT_DEBUG
string str = pVarStrSiteName->strGetDataSrc();
printf("%s%d", str.c_str(), page);
qDebug()<<str.c_str()<<page;
#endif
}
void FSpider::y3() { page++; }
void FSpider::y4() { page = 1; }
Tidak ada kode yang mengimplementasikan fungsi yang disebut event loop. Tidak ada kebutuhan untuk itu. fungsinya dilakukan oleh inti dari lingkungan CPSU (a). Ini membuat objek dan mengelola eksekusi paralelnya dalam waktu diskrit.
4. Kesimpulan
Singkat tidak selalu merupakan saudara perempuan dari bakat, dan terkadang itu juga merupakan tanda kelekatan lidah. Benar, sulit untuk membedakan satu sama lain sekaligus. Kode Python seringkali lebih pendek dari kode C ++. Tapi ini tipikal untuk kasus sederhana. Semakin kompleks solusinya, semakin sedikit perbedaan ini. Pada akhirnya, kompleksitas solusi pun ditentukan oleh kapabilitas model. Model otomat jauh lebih kuat daripada diagram blok.
Automata dan paralelisasi, pertama-tama, adalah cara yang sangat efektif untuk memecahkan masalah kompleksitas, melawannya, dan bukan cara untuk meningkatkan kecepatan program. Karena semua ini adalah model otomat, paralelisme sulit diterapkan dengan Python, maka, terlepas dari semua chip, baterainya, dan banyak lagi, sulit bagi saya untuk bergoyang ke arahnya. Saya akan lebih memperhatikan lingkungan C ++, dan tidak terlalu membenarkan pengenalan coroutine yang sama ke dalamnya. Model ini bersifat sementara dan alasan penerapannya sebagian besar dipaksakan. Apa yang akan kita lakukan dengan "kruk" ini ketika masalah pemilihan model paralel diselesaikan?
Oleh karena itu, maaf, preferensi saya masih pada sisi C ++. Dan jika Anda mempertimbangkan bidang minat profesional saya - sistem industri yang disebut waktu nyata "menyeramkan", maka saya tidak punya pilihan seperti itu. Ya, beberapa jenis lingkungan, beberapa jenis layanan dapat dibuat menggunakan Python. Nyaman, cepat, ada banyak prototipe, dll. dll. Tapi inti dari solusi, model paralelnya, logika proses itu sendiri jelas C ++, automata jelas. Di sini automata, tentu saja, lebih penting dan aturannya. Tapi bukan coroutine :)
Selain itu ... Tonton video [2] , perhatikan implementasi model roket. Tentangnya, mulai sekitar menit ke-12, video tersebut menceritakan. Hormat kepada dosen karena menggunakan mesin :) Dan untuk suguhan manis, solusi lain dari [3]... Ini dalam semangat pemrograman asynchronous dan asyncio. Sebenarnya, semuanya dimulai dengan contoh ini - implementasi automata bersarang dengan Python. Di sini, kedalaman sarang bahkan lebih besar daripada contoh yang dijelaskan di atas. Kode 6 menunjukkan kode sumber dan mitra Python robotnya. Dalam gambar. 2 adalah model minum teh otomatis, dan Daftar 7 menunjukkan implementasi C ++ yang setara untuk VKP (a). Bandingkan, analisis, tarik kesimpulan, kritik ...
Kode 6. Membaca dan minum teh secara asinkron dengan Python
import asyncio
import time
# # Easy Python. Asyncio python 3.7 https://www.youtube.com/watch?v=PaY-hiuE5iE
# # 10:10
# async def teatime():
# await asyncio.sleep(1)
# print('take a cap of tea')
# await asyncio.sleep(1)
#
# async def read():
# print('Reading for 1 hour...')
# await teatime()
# print('...reading for 1 hour...')
#
# if __name__ == '__main__':
# asyncio.run(read())
class PSleep:
def __init__(self, t, p_FSM): self.SetTime = t; self.nState = 0; self.bIfLoop = False; self.p_mainFSM = p_FSM
def x1(self): return time.time() - self.t0 <= self.SetTime
def y1(self): self.t0 = time.time()
def loop(self):
if (self.nState == 0): self.y1(); self.nState = 1
elif (self.nState == 1):
if (not self.x1()): self.nState = 4
class PTeaTime:
def __init__(self, p_FSM): self.nState = 0; self.bIfLoop = False; self.p_mainFSM = p_FSM;
def y1(self): self.bIfLoop = False; automaton.append(sl); automaton[-1].bIfLoop = True; automaton[-1].nState = 0
def y2(self): print('take a cap of tea')
def loop(self):
if (self.nState == 0): self.y1(); self.nState = 1
elif (self.nState == 1): self.y2(); self.nState = 2
elif (self.nState == 2): self.y1(); self.nState = 3
elif (self.nState == 3): self.nState = 4
class PRead:
def __init__(self): self.nState = 0; self.bIfLoop = False;
def y1(self): print('Reading for 1 hour...')
def y2(self): self.bIfLoop = False; automaton.append(rt); automaton[-1].bIfLoop = True; automaton[-1].nState = 0
def loop(self):
if (self.nState == 0): self.y1(); self.nState = 1
elif (self.nState == 1): self.y2(); self.nState = 2
elif (self.nState == 2): self.y1(); self.nState = 33; self.bIfLoop = False
read = PRead()
rt = PTeaTime(read)
sl = PSleep(5, rt)
automaton = []
automaton.append(read); automaton[-1].bIfLoop = True
while True:
ind = 0;
while True:
while ind < len(automaton):
if automaton[ind].nState == 4:
automaton[ind].p_mainFSM.bIfLoop = True
automaton.pop(ind)
ind -=1
elif automaton[ind].bIfLoop:
automaton[ind].loop()
elif automaton[ind].nState == 33:
exit()
ind += 1
ind = 0
Angka: 2. Model minum teh otomatis
Kode 7. Membaca dan minum teh secara asinkron dalam C ++
#include "lfsaappl.h"
class FRead :
public LFsaAppl
{
public:
LFsaAppl* Create(CVarFSA *pCVF) { Q_UNUSED(pCVF)return new FRead(nameFsa); }
FRead(string strNam);
virtual ~FRead(void);
protected:
void y1(); void y2(); void y3();
LFsaAppl *pFRealTime{nullptr};
};
#include "stdafx.h"
#include "FRead.h"
#include "FTeaTime.h"
#include <QDebug>
static LArc TBL_Read[] = {
LArc("s1","s2","--","y1"), // Reading for 1 hour...
LArc("s2","s3","--","y2"), // Call(TeaTime)
LArc("s3","s4","--","y1"), // Reading for 1 hour...
LArc("s4","s5","--","y3"), // sleep(5)
LArc("s5","s1","--","--"), //
LArc()
};
FRead::FRead(string strNam):
LFsaAppl(TBL_Read, strNam)
{ }
FRead::~FRead(void) { if (pFRealTime) delete pFRealTime; }
void FRead::y1() {
#ifdef QT_DEBUG
qDebug()<<"Reading for 1 hour...";
#endif
}
void FRead::y2() {
if (pFRealTime) delete pFRealTime;
pFRealTime = new FTeaTime("TeaTime");
pFRealTime->FCall(this);
}
void FRead::y3() { FCreateDelay(5000); }
#include "lfsaappl.h"
class FTeaTime :
public LFsaAppl
{
public:
FTeaTime(string strNam);
protected:
void y1(); void y2();
};
#include "stdafx.h"
#include "FTeaTime.h"
#include <QDebug>
#include "./LSYSLIB/FDelay.h"
static LArc TBL_TeaTime[] = {
LArc("s1", "s2","--","y1"),// sleep(1)
LArc("s2", "s3","--","y2"),// take a cap of tea
LArc("s3", "s4","--","y1"),// sleep(1)
LArc("s4", "00","--","--"),//
LArc()
};
FTeaTime::FTeaTime(string strNam):
LFsaAppl(TBL_TeaTime, strNam)
{ }
void FTeaTime::y1() { FCreateDelay(2000); }
void FTeaTime::y2() {
#ifdef QT_DEBUG
qDebug()<<"take a cap of tea";
#endif
}
PS
Setelah menulis artikel, setelah membaca terjemahan artikel oleh Yerain Diaz [4] , saya berkenalan dengan tampilan lain yang agak menarik dan mengagumi coroutine pada umumnya dan asyncio pada khususnya. Terlepas dari kenyataan ini dan yang lainnya menyukainya, kami masih akan "pergi ke arah lain" :) Saya hanya setuju pada satu hal dengan Rob Pike, bahwa "Concurrency Is Not Parallelesm". Daya saing, bahkan bisa dikatakan lebih keras, tidak ada hubungannya dengan paralelisme sama sekali. Dan perlu dicatat bahwa Google Terjemahan menerjemahkan frasa ini sebagai "Paralelisme bukanlah paralelisme." Pria bernama Google itu pasti salah. Tapi seseorang meyakinkannya tentang ini? :)
literatur
- Shultais Education. 1. . [ ], : www.youtube.com/watch?v=BmOjeVM0w1U&list=PLJcqk6mrJtxCo_KqHV2rM2_a3Z8qoE5Gk, . . . ( 01.08.2020).
- Computer Science Center. 9. async / await ( Python). [ ], : www.youtube.com/watch?v=x6JZmBK2I8Y, . . . ( 13.07.2020).
- Easy Python. Asyncio python 3.7. [ ], : www.youtube.com/watch?v=PaY-hiuE5iE, . . . ( 01.08.2020).
- Yeray Diaz. Asyncio untuk pengembang python yang berlatih. [Sumber daya elektronik], Mode akses: www.youtube.com/watch?v=PaY-hiuE5iE , gratis. Bahasa. Rusia (tanggal pengobatan 08/01/2020).