🉐 🚏 ✍️ コルティンのない世界。プログラマーのためのクラッチ-asyncio ⚰️ 🏴󠁧󠁢󠁳󠁣󠁴󠁿 🗡️

1.はじめに

飛ぶことを学んだ人はもう這うことはありません。しかし、原則として「飛べない」人に対しても傲慢であってはなりません。どちらもごく普通のことです。どちらも尊敬され、尊敬されています。人にとって、これは職業を選ぶようなものです。あなたは、従来、パイロットかドライバーのどちらかです。同じ動物の場合、それは同じです-あなたはワシかオオカミのどちらかです、すなわち飛ぶか逃げる（逃げる）しかし、彼の概念、カテゴリー、態度、思考の中で男性だけがキャラクターに特徴を与え、彼らに対して彼自身の態度を発達させました。確かに、ニュアンスがあります。だから、おそらく、それはパイロットの職業よりも立派でロマンチックですが、これをトラック運転手や航空機の設計者に説得してみてください？！そして、ここで議論するのは難しいです：今でも多くの宇宙飛行士がいますが、2番目の女王はまだいません！

私たちはプログラマーです。程度はさまざまかもしれませんが、確かにいくつかあります。つまり、私たちは異なっており、さまざまな方法で考えることもできます。プログラマーが一貫してしか考えていないという声明は、人が走るだけであるという事実と同じように、一方的で、有害で、冒涜的でさえあります。彼は時々-そして飛ぶ。パイロットのように定期的に行う人もいれば、宇宙飛行士のように数か月間も継続的に行う人もいます。一貫した思考のアイデアは、人間の能力を低下させます。ある時点で、しばらくの間、あなたはそれを信じることさえできますが、「それでも、それは変わります」-これは遅かれ早かれ人生が犠牲になるという事実についてです。

PythonのAsyncioは、比喩的に言えば、誤った並列思考の飛行を模倣するソフトウェアクラッチです。手を振ってバウンドするようなものです。それは時々、面白くて不器用に見えます。特定の状況では、これも解決策です。水たまりを越えて汚れることができますが、強度が許せば、飛び越える方がよいでしょう。しかし、おそらくプログラマーは力を欠いていますか？

課せられた「ソフトウェアクラッチ」を破棄して、ソフトウェアルーチンの上に急上昇してみましょう。そして、それをジャンプではなく、あるいはそれほど高くも長くもしないようにしますが、それでも、特にクラッチと比較して、フライトです。結局のところ、かつてモザイスキーアレクサンダーフェドロビッチ（モスクワ地域のモザイスキー市裁判所と混同しないでください;）または同じライト兄弟が初めて空中で数百メートルを克服しました。はい、そして現代の航空機のテストは、滑走路と滑走路からの短期間の分離から始まります。

2.asyncioを使用した非常に単純な例

Pythonでの飛行から始めましょう。フライトプログラムは簡単です。ヒューズラグに「Blog」、「News」、「Forum」という名前の飛行機があります（ただし、スパイダーの画像の元のバージョンでは、[1]を参照してください）。彼らは同時に離陸します。誰もが特定の時間内にパスのセグメントを飛行し、たとえば、セグメントの番号がカバーされたフラグを投げる必要があります。これは3回実行する必要があります。そして、着陸するだけです。

Pythonでは、この動作のモデルが記述され、リスト1のコードによってシミュレートされます。

リスト1.スパイダープレーンのPythonコード

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

このような「フライト」のシミュレーション結果は次のとおりです。

ブログ1

ニュース1

フォーラム1

ブログ2

ニュース2

フォーラム2

ブログ3

ニュース3

フォーラム

33.00

なぜこれがビデオ[1]で詳細に説明されているのか。しかし、想像力と同時で、私たちみんな（シナリオに従って-非同期）の飛行私たち3「プレーン」になるasyncioを使用せずに-自動モデルに基づいて異なる方法で提示します。たとえば、リスト2は、オートマトン遅延のコードを示しています。これは、リスト1のawait asyncio.sleep（1）という行で表される、asyncioモジュールからの非同期遅延の類似物です。

リスト2.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

遅延値と遅延オブジェクトを作成したオブジェクトへのポインタは、クラスコンストラクタを介して渡されます。ポインタは、遅延を削除した後、作成時に停止された親プロセスを続行するプロセス制御機能に必要です。

リスト3は、非同期スパイダープレーンに対応するオートマトンを示しています（リスト1も参照）。最も悪夢のような場合でも、Pythonプログラミングエースがこれを夢見ない可能性が非常に高いです。4行のソースコードは15倍になりました！これは、一般的な典型的なPythonコード、特にasycioを賞賛する理由ではありませんか、少なくとも、オートマトンプログラミングに対する「通常のテクノロジー」の利点の証拠ではありませんか？

リスト3.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

自動フライトの結果は次のとおりです。

ニュース1

フォーラム1

ブログ1

ブログ2

ニュース2

フォーラム2

ニュース3

フォーラム3

ブログ

33.00

しかし、話し合いましょう。コードサイズの増加は、Pythonのポインタの問題が原因でした。その結果、ページごとにクラスを作成する必要があり、コードが3倍になりました。したがって、約15ではなく、約5倍の音量で話す方が正しいです。プログラミングにおけるより熟練した「Pythonパイロット」は、この欠点を取り除くことさえできるかもしれません。

しかし、主な理由はまだポインターではありません。以下に示すC ++コードは、ポインターを完全に自由に操作できるため、クラスごとにさらに多くの行があります。その理由は、使用されている計算モデル、その記述の言語、およびそれに基づくアルゴリズムの実装へのアプローチです。図：図１は、ブロック図形式の従来のスパイダー平面モデルおよびオートマトンモデルを示している。同等の変換が可能ですが、外見上および品質上、これらは異なるモデルであることがわかります。 Automataには状態がありますが、ブロック図にはそれらの痕跡すらありません。 Automataは、定義上、離散時間で動作し、ブロック図はこれを夢見さえしません。これはすべて、モデルの実装に特定の義務を課します。

離散時間の概念がないことは、既存のブロック図プログラミングモデルの問題の本質であり、厳密に言えば、それに対して実現不可能なことを実現する必要があります。並列プロセス。オートマトンの場合、並列プロセス（および非同期）のモデルとしてのオートマトンネットワークが自然な状態であることを思い出してください。

図：1.スパイダープレーンの自動モデルとブロック図モデル

ただし、別のプロセスのレベルでも、モデルには、モデルの言語と実装に投影される違いがあります。これらの品質のおかげで、一貫性のあるブロック図の謝罪者は、明示的または暗黙的に、それを非常にコンパクトに記述することを可能にする言語構造を作成しました。同じforループ、または少なくとも暗黙的に暗黙的に実行される演算子のシーケンス（アクションy1、y2、y3）を使用します。

フローチャートの場合、問題なく1つのボックスにアクションをリストできます。これにより、アクションの順次的な性質が変わることはありません。オートマトンが状態s2、s3の遷移を状態s1のサイクルに置き換え、アークを同じアクションでマークすると、アルゴリズムの意味が変わります。その作業に並列処理を導入します。上記のアクションは厳密に順番に実行する必要があるため、これによりオートマトンモデルの外観が事前に決定されます（図1を参照）。有限オートマトンは、「二重思考」を許可しないモデルです。

ブロック図に離散時間がないことが彼らの利点でした。しかし今、これは彼らの主な欠点になっています。それは冒涜的ではないように見えるかもしれないので、それは影響を及ぼします、そして考え方。シーケンシャル言語は、プログラマーに他の何かを否定することによって、プログラマーのシーケンシャルな考え方を正当化します-並列。これは、既存の非同期プログラミングの構築を正当化し、同じasyncioパッケージのオペレーターのセットと機能を提示するものです。そして、シーケンシャルプログラムに精通しているプログラマーが非同期（ほぼ並列）に変換できるのは、まさにこのアプローチであると主張されています。

しかし、記事とその画像のトピックに戻ります。私たちは「飛行機」が欲しかったのですが、それを手に入れました！フライト、より正確には、目に見える結果は、外観は多少異なりますが、本質的に完全に区別できません。それらは、フラグが選択され、プロトコルに異なる順序で記録されるように解釈できますが、「飛行機」自体は本来のように飛行しました。同時にそして同時に彼らの旗を捨てた。そして、それらがどのような順序で記録されたか-彼らが言うように、ケースは10番目です。主なものは実現され、実行されます：それらのリリースの順序と時間はフライトプログラムに対応します

コードを短くすることができます。したがって、明らかに、1つのクラスのコードのみに制限することができます。イベントループコードを非表示にすることもできます。同時に、ソースコードで、非同期の背後に隠されているエンジンコンパートメントコードを開いてオペレーターを待つ場合、オートマトンコードのボリュームはそれほど怖くないでしょう。

3.Pythonでオートマトンを実装する際の問題について

自動コードの出現を引き起こした問題についてさらに詳しく見ていきましょう。そこに隠す最後のものは、ソースコードと比較してこれまでのところ巨大に見えます。しかし、Mozhaiskyの最初の航空機は、現代の「乾燥」とはほど遠いものであり、最初の車は、現代のどの航空機ともそれほど変わらなかったことに注意してください。提示されたオートマトンコードの問題は、Python言語の現在の理解に大きく関係しており、おそらく、言語自体の機能にはそれほど関係がないことを強調しておきます。

それにもかかわらず、最初の問題は、オートマトンモデルの記述言語に関連しています。 C ++では、言語によって解決されます。 Pythonではそのような可能性は見当たりません。残念ながら、彼らが今時々言うように、まったく言葉から。そのため、if-elif-else言語の制御演算子に基づいてオートマトンを実装する方法を基本としました。さらに、CPSU（a）では、オートマトン自体に加えて、並列処理を完全に実装するためにシャドウメモリとオートマトンスペースが導入されたことを思い出します。これがないと、オートマトンプログラミングの可能性は非常に限られており、多くの点で劣っています。

すでに述べた次の問題はポインターです。 C ++では問題ありません。 CPSU（a）のフレームワーク内で、OOPパラダイムに従って、基本的なオートマトンクラスが作成され、そこから適用されたオートマトンクラスが生成され、それらのパラメーターはポインターだけでなくアドレスにもなります。これらすべてにより、多くの並列相互作用プロセスを含むタスクを簡単、コンパクト、非常に効率的に記述および実装できます。

以下は、検討した例に相当するC ++オートマトンクラスのコードです。リスト4の遅延コードは、リスト1のawait asyncio.sleep（1）の行と同等です。グラフ形式では、図1のFAwaitSleepオートマトンモデルに対応します。1.そのような、そしてそのようなオートマトンだけが非同期と見なすことができ、計算フローを遅くすることはありません。同じ図のFSleepは、通常のsleep（）演算子に対応します。より簡単ですが、y1の作用により通常の順次遅延が発生するため、離散時間モデルが破壊されることが保証されています。そして、これはもはや何の役にも立たない。

リスト4.非同期遅延コード

//  (  )
#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; }

スパイダープレーンのC ++コードをリスト5に示します。このコードは、Pythonコードのブロック図よりも、そのモデルにはるかに適しています。特に、オートマトンの遷移テーブルとオートマトングラフの外観を比較すると。それらは、同じ抽象的な概念、つまりオートマトンを記述するための単純に異なる形式です。また、遅延を作成するときに親クラスへのポインタがどのように渡されるかを示します（アクティビティy1のFCallメソッドの呼び出しを参照）。

リスト5.サイトページの読み取りをシミュレートするスパイダープレーンのコード

// "".   
#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; }

いわゆるイベントループの機能を実装するコードはありません。単にそれの必要はありません。その機能は、CPSU（a）環境のコアによって実行されます。オブジェクトを作成し、それらの並列実行を個別の時間で管理します。

4.結論

簡潔さは必ずしも才能の姉妹であるとは限らず、時にはそれは舌の結びつきの兆候でもあります。確かに、一度に区別することは困難です。多くの場合、PythonコードはC ++コードよりも短くなります。しかし、これは単純なケースでは一般的です。ソリューションが複雑になるほど、この違いは少なくなります。結局、ソリューションの複雑さでさえ、モデルの機能によって決定されます。オートマトンモデルは、ブロック図よりもはるかに強力です。

自動化と並列化は、まず第一に、複雑さの問題を解決し、それと戦うための非常に効果的な手段であり、プログラムの速度を上げる手段ではありません。これはすべてオートマトンモデルであるため、並列処理をPythonで実装するのは困難です。そのため、チップやバッテリーなどすべてにもかかわらず、その方向に私を説得するのは困難です。私はC ++環境にもっと注意を払い、同じコロチンをそれに導入することはあまり正当化されません。このモデルは一時的なものであり、その実装の理由は大部分が強制されています。そして、並列モデルを選択する問題が解決されたら、この「クラッチ」をどうしますか？

したがって、申し訳ありませんが、私の好みはまだC ++側です。そして、あなたが私の専門的な興味のある分野、いわゆる「不気味な」ハードリアルタイムの産業システムを考えると、私はそのように選択することはできません。はい、ある種の環境、ある種のサービスはPythonを使用して作成できます。便利、高速、プロトタイプがたくさんあります。等しかし、ソリューションの中核である並列モデル、プロセス自体のロジックは、明確にC ++であり、明確に自動化されています。もちろん、ここではオートマトンがより重要であり、支配的です。しかし、coroutinesではありません:)

さらに...ロケットモデルの実装に注意を払いながら、ビデオ[2]をご覧ください。彼女について、12分頃からビデオが語ります。機械を使用するための講師への敬意:)そして甘い御馳走のために、[3]からの別の解決策..。それは非同期プログラミングと非同期の精神に基づいています。実際、すべてはこの例、つまりPythonでのネストされたオートマトンの実装から始まりました。ここでは、入れ子の深さは上記の例よりもさらに大きくなっています。リスト6は、ソースコードとそれに対応するオートマトンPythonを示しています。図では 2は自動茶飲用モデルであり、リスト7はVKP（a）の同等のC ++実装を示しています。比較、分析、結論の引き出し、批判...

リスト6.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

図：2.お茶を飲む自動モデル

リスト7.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

すでに記事を書いた後、Yerain Diaz [4]による記事の翻訳を読んだ後、私は別のかなり興味深く、むしろ称賛に値する、一般的なコロチン、特に非同期の見方に精通しました。この事実や他の人がそれを好むにもかかわらず、私たちはまだ「反対の方向に進む」でしょう:)私はRob Pikeと、「並行性は並列性ではない」という1つのことに同意します。競争力は、より厳しいとさえ言えるかもしれませんが、並列処理とはまったく関係がありません。そして、GoogleTranslateがこのフレーズを「並列処理は並列処理ではない」と翻訳していることは注目に値します。グーグルという男は確かに間違っています。しかし、誰かが彼にこれを納得させましたか？:)

文献

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).
イェレイディアス。練習中のpython開発者のためのAsyncio。[電子リソース]、アクセスモード：www.youtube.com/watch？v = PaY-hiuE5iE、無料。言語。ロシア（治療日2020年8月1日）。

コルティンのない世界。プログラマーのためのクラッチ-asyncio

1.はじめに

2.asyncioを使用した非常に単純な例

3.Pythonでオートマトンを実装する際の問題について

4.結論

PS

文献

More articles: