✋🏽 👸🏿 🖇️ コルティンのない世界。ジェネレータイテレータ 🏝️ 🥡 📦

1.はじめに

問題をできるだけ混乱させるために、解決策をプログラマーに任せてください;）。しかし、真剣に、私の意見では、コロチンにも同様のことが起こります。なぜなら、喜んでかどうかにかかわらず、それらは状況を曖昧にするために使用されるからです。後者は、どこにも行かない並列プログラミングの問題がまだあるという事実によって特徴付けられ、そして最も重要なことに、コルチンはそれらの基本的な解決に貢献しません。

用語から始めましょう。「彼らは何回世界に語ったことがある」が、これまでのところ「世界」は非同期プログラミングと並列プログラミングの違いについて疑問を投げかけている（[1]の非同期のトピックに関する議論を参照）。非同期性と並列性を理解する問題の核心は、並列性自体を定義することから始まります。それは単に存在しません。ある種の直感的な理解があり、それはしばしば異なる方法で解釈されますが、「2と2」の操作の結果についての議論ほど建設的にすべての質問を取り除く科学的定義はありません。

また、これもすべて存在しないため、用語と概念が混同されているため、並列プログラミングと同時プログラミング、非同期プログラミング、リアクティブプログラミングなどを区別しています。等Felixのような機械式計算機がソフトウェア計算機とは異なる動作をすることに気付くのに問題が生じる可能性は低いと思います。しかし、正式な観点から、すなわち一連の操作と最終結果では、それらの間に違いはありません。この原則は、並列プログラミングの定義で考慮に入れる必要があります。

「不器用な」Felixやソフトウェア計算機のような一貫した結果につながる、並列処理を記述するための厳密な定義と透過的な手段が必要です。「並列処理」の概念をその実装手段（同じコアの数）に関連付けることは不可能です。そして、「内部」にあるもの-これは、主に「機械」の実装に従事している人だけに関心があり、そのような従来の「並列計算機」を使用している人には関心がないはずです。

しかし、私たちは私たちが持っているものを持っています。そして、流行ではないにしても、私たちは、コルティンと非同期プログラミングについて活発な議論をしています。そして、マルチスレッドにうんざりしているように見えても、他に何かが提供されていない場合は、他に何をすべきでしょうか。彼らはある種の魔法についてさえ話します;）しかし、あなたが理由を理解すればすべてが明らかになります。そして、それらはまさにそこにあります-並列処理の面にあります。その定義とその実装。

しかし、プログラミングの科学（それ以来のコンピューター）のグローバルな、そしてある程度は哲学的な高さから、私たちの「罪深い地球」へと降りていきましょう。ここでは、現在人気のあるコトリン言語のメリットを損なうことなく、Python言語への情熱を認めたいと思います。おそらくいつか、そして他の状況では、私の好みは変わるでしょうが、実際、これまでのところすべてがそうです。

これにはいくつかの理由があります。その中には、Pythonへの無料アクセスがあります。これは最強の議論ではありません。同じQtの例では、状況はいつでも変わる可能性があると述べています。しかし、PythonはKotlinとは異なり、少なくともJetBrainsと同じPyCharm環境の形で無料ですが（特に感謝します）、私の同情はその側にあります。また、インターネット上のPythonの例など、教育的で非常に現実的なロシア語の文献が大量にあることも魅力的です。コトリンでは、それらはその数ではなく、それらの多様性はそれほど大きくありません。

おそらく少し先に、ソフトウェアの並列処理と非同期性の定義と実装の問題のコンテキストでPythonをマスターした結果を提示することにしました。これは記事[2]によって開始されました..。今日は、ジェネレーター-コルルーチンのトピックについて検討します。それらへの私の興味は、特定の、興味深いが、現時点ではあまり馴染みのない、現代の言語/プログラミング言語の可能性を認識する必要性によって刺激されています。

私は実際には純粋なC ++プログラマーなので、これは多くのことを説明しています。たとえば、Pythonのコロチンとジェネレーターが長い間存在していた場合、C ++ではまだその地位を獲得していません。しかし、C ++は本当にそれを必要としますか？私の意見では、プログラミング言語は合理的に拡張する必要があります。 C ++は可能な限り引っ張ったようで、今は急いで追いつくようにしています。しかし、同様の同時実行の問題は、coroutines / coroutinesよりも基本的な他の概念やモデルを使用して実装できます。そして、この声明の背後に言葉だけがないという事実は、さらに示されます。

私たちがすべてを認めるのであれば、私はC ++に関してかなり保守的であることも認めます。もちろん、そのオブジェクトとOOP機能は私にとって「私たちのすべて」ですが、私は、言うまでもなく、テンプレートに批判的です。まあ、私は彼らの独特の「鳥の言語」を実際に見たことがありませんでした。それは、見たところ、コードの認識とアルゴリズムの理解を非常に複雑にします。時々私は彼らの助けに頼ることさえしましたが、片方の手の指でこれらすべてに十分です。私はSTLライブラリを尊重し、それなしでは実行できません:)したがって、この事実からでも、テンプレートについて疑問を持つことがあります。だから私はまだできる限りそれらを避けています。そして今、私はC ++の「テンプレートcoroutines」を震えながら待っています;）

Pythonは別の問題です。テンプレートが入っていることにまだ気づいておらず、落ち着きます。しかし、その一方で、これは奇妙なことに、憂慮すべきことです。しかし、Kotlinコード、特にそのエンジンコンパートメントコードを見ると、不安はすぐに消えます;）しかし、これはまだ習慣と私の偏見の問題だと思います。時間が経つにつれて、それらを適切に認識するように自分自身を訓練することを願っています（テンプレート）。

しかし...コルティンに戻ります。現在、彼らはコルティンという名前で呼ばれていることがわかりました。名前の変更で何が新しくなりましたか？はい、実際には何もありません。前と同じように、セットは順番に考慮されます実行される機能。以前と同じように、関数を終了する前、ただし作業が完了する前に、戻り点が固定され、後で作業が再開されます。切り替え順序が指定されていないため、プログラマー自身が独自のスケジューラーを作成してこのプロセスを制御します。多くの場合、これは関数のループスルーにすぎません。たとえば、OlegMolchanovによるビデオのRoundRobinイベントサイクル[3]など。

これは、コルルーチンと非同期プログラミングの最新の紹介が通常「指で」どのように見えるかです。このトピックに没頭すると、新しい用語や概念が生まれることは明らかです。ジェネレーターはその1つです。さらに、それらの例は「並列設定」を示すための基礎になりますが、すでに私の自動解釈にあります。

2.データリストのジェネレータ

だから-ジェネレータ。非同期プログラミングとコロチンは、しばしばそれらに関連付けられています。 Oleg Molchanovからの一連のビデオは、これらすべてについて語っています。そのため、彼はジェネレーターの重要な機能を「前回停止したのと同じ場所から実行を継続するために関数の実行を一時停止する機能」と呼んでいます（詳細については[3]を参照）。そして、これでは、すでにかなり古いコロチンの定義について上記で述べたことを考えると、新しいものは何もありません。

しかし、結局のところ、ジェネレーターはデータのリストを作成するための非常に特殊な用途を見つけました。このトピックの紹介は、Egorov Artem [4]のビデオですでに取り上げられています。..。しかし、どうやら、そのようなアプリケーションによって、私たちは質的に異なる概念、つまり操作とプロセスを混ぜ合わせています。言語の記述機能を拡張することにより、発生する可能性のある問題を大部分理解します。ここでは、彼らが言うように、あまりプレイしないでください。データを記述するためにgenerators-coroutinesを使用することは、まさにこれに貢献しているように私には思えます。 Oleg Molchanovは、ジェネレーターをデータ構造に関連付けることに対しても警告し、「ジェネレーターは関数である」ことを強調していることに注意してください[3]。

ただし、ジェネレータを使用してデータを定義することに戻ります。リストアイテムを計算するプロセスを作成したことを隠すのは難しいです。したがって、プロセスなどのリストについてはすぐに疑問が生じます。たとえば、定義上、コルチンが「一方向」でしか機能しない場合、どのように再利用するのでしょうか。プロセスにインデックスを付けることができない場合、その任意の要素を計算するにはどうすればよいですか？等。等Artemはこれらの質問に答えることはなく、リストの要素への繰り返しのアクセスは整理できず、索引付けは受け入れられないと警告するだけです。インターネットで検索すると、私にも同様の質問があるだけでなく、提案されている解決策はそれほど簡単で明白ではないことがわかります。

もう1つの問題は、リスト生成の速度です。これで、各coroutineスイッチでリストの単一要素を形成します。これにより、データ生成時間が長くなります。「バッチ」で要素を生成することにより、プロセスを大幅に加速できます。しかし、おそらくこれには問題があります。すでに実行中のプロセスを停止するにはどうすればよいですか？または、他の何か。選択したアイテムのみを使用して、リストをかなり長くすることができます。このような状況では、効率的なアクセスのためにデータの記憶がよく使用されます。ちなみに、Pythonに関するこのトピックに関する記事をすぐに見つけました[5]を参照してください（オートマトンに関するメモ化の詳細については、記事[6]を参照してください）。しかし、この場合はどうですか？

リストを定義するためのそのような構文の信頼性も疑わしいかもしれません。括弧の代わりに角括弧を誤って使用したり、その逆を行ったりするのは簡単です。一見美しくエレガントなソリューションが実際には特定の問題につながる可能性があることが判明しました。プログラミング言語は、技術的で柔軟性があり、不本意な間違いを防ぐ必要があります。

ちなみに、リストとジェネレーターの長所と短所についてのトピックについては、上記の発言と交差して、OlegMolchanovによる別のビデオを見ることができます[7]。

3.ジェネレーター-コルルーチン

Oleg Molchanov による次のビデオ[8]は、コロチンの作業を調整するためのジェネレーターの使用について説明しています。実際、それらはこれを目的としています。コルチンを切り替える瞬間の選択に注意が向けられます。それらの配置は単純なルールに従います-ブロッキング関数の前にyieldステートメントを置きます。後者は関数として理解され、他の操作と比較して戻り時間が非常に長いため、計算はそれらの停止に関連付けられます。このため、それらはブロッカーと呼ばれていました。

切り替えは、中断されたプロセスが、ブロッキングコールが待機しないときに正確に作業を続行する場合に有効ですが、作業はすぐに完了します。そして、このために、このすべての「騒ぎ」は、coroutine / coroutineモデルを中心に開始されたようであり、したがって、非同期プログラミングの開発に弾みがつけられました。ただし、並列コンピューティングの仮想モデルを作成するという、coroutinesの元のアイデアはまだ異なっていました。

検討中のビデオでは、コロチンの一般的な場合と同様に、コルチン操作の継続は、イベントスケジューラである外部環境によって決定されます。この場合、event_loopという名前の関数で表されます。そして、すべてが論理的であるように思われます。スケジューラーは分析を実行し、必要なときに正確にnext（）演算子を呼び出すことによって、ルーチンの作業を続行します。問題は、予期しない待機にあります。スケジューラーは非常に複雑になる可能性があります。 Molchanovの以前のビデオ（[3]を参照）では、すべてが単純でした。制御の単純な代替転送が実行されましたが、ロックはありませんでした。対応する呼び出しはありませんでした。それでも、いずれにせよ、少なくとも単純なスケジューラーが必要であることを強調します。

問題1。 , next() (. event_loop). , , yield. - , , next(), .

2. , select, — . .

しかし、重要なのはプランナーの必要性でさえありませんが、彼が彼にとって珍しい機能を引き受けるという事実です。多くのコロチンの共同操作のためのアルゴリズムを実装する必要があるという事実によって、状況はさらに複雑になります。Oleg Molchanovが言及した2つのビデオで説明されているスケジューラーの比較は、同様の問題を非常に明確に反映しています。[8]のソケットスケジューリングアルゴリズムは、[3]の「カルーセル」アルゴリズムよりも著しく複雑です。

3.コルティンのない世界へ

オートマトンで対抗する、コルティンのない世界が可能であると確信しているので、同様のタスクがすでにそれらによってどのように解決されているかを示す必要があります。ソケットを操作する同じ例を使用して、これを示しましょう。その最初の実装は、すぐに理解できるほど簡単ではないことが判明したことに注意してください。これは、ビデオの作者自身によって繰り返し強調されています。他の人は、コルティンの文脈で同様の問題に直面しています。したがって、認識、理解、デバッグなどの複雑さに関連するコロチンの欠点。ビデオ[10]で説明されています。

まず、検討中のアルゴリズムの複雑さについて簡単に説明します。これは、カスタマーサービスプロセスの動的で複数の性質によるものです。これを行うために、特定のポートをリッスンするサーバーが作成され、要求が表示されると、それに到達する多くのクライアントサービス関数が生成されます。多くのクライアントが存在する可能性があるため、それらは予期せず表示されます。動的リストは、ソケットにサービスを提供し、それらと情報を交換するプロセスから作成されます。ビデオ[8]で説明されているPythonジェネレータソリューションのコードをリスト1に示します。

リスト1.ジェネレーターのソケット

import socket
from select import select
tasks = []
to_read = {}
to_write = {}

def server():

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server_socket.bind(('localhost', 5001))
    server_socket.listen()

    while True:
        yield ('read', server_socket)
        client_socket, addr = server_socket.accept()    
        print('Connection from', addr)
        tasks.append(client(client_socket, addr))       
    print('exit server')

def client(client_socket, addr):

    while True:
        yield ('read', client_socket)
        request = client_socket.recv(4096)              

        if not request:
            break
        else:
            response = 'Hello World\n'.encode()

            yield ('write', client_socket)

            client_socket.send(response)                
    client_socket.close()                               
    print('Stop client', addr)

def event_loop():
    while any([tasks, to_read, to_write]):

        while not tasks:

            ready_to_read, ready_to_write, _ = select(to_read, to_write, [])

            for sock in ready_to_read:
                tasks.append(to_read.pop(sock))

            for sock in ready_to_write:
                tasks.append(to_write.pop(sock))
        try:
            task = tasks.pop(0)

            reason, sock = next(task)   

            if reason == 'read':
                to_read[sock] = task
            if reason == 'write':
                to_write[sock] = task
        except StopIteration:
            print('Done!')
tasks.append(server())
event_loop()

サーバーとクライアントのアルゴリズムはかなり基本的です。しかし、サーバーがクライアント機能をタスクリストに追加することは憂慮すべきことです。さらに-詳細：event_loopイベントループのアルゴリズムを理解することは困難です。少なくともサーバープロセスが常に存在する必要がある場合、タスクリストが空になるまでは？..

次に、辞書to_readとto_writeが導入されます。辞書を扱う作業そのものには、別の説明が必要です。通常のリストで作業するよりも難しいです。このため、yieldステートメントによって返される情報はそれらに合わせて調整されます。すると、辞書の周りで「タンバリンと踊る」が始まり、すべてが一種の「シーズ」のようになります。何かが辞書に配置されているように見え、そこからタスクリストに入るなどです。等あなたは「頭を壊す」ことができ、これらすべてを整理します。

そして、目前のタスクの解決策はどのようになりますか？オートマトンが、ビデオですでに説明したソケットを操作するプロセスと同等のモデルを作成することは論理的です。サーバーモデルでは、何も変更する必要がないように見えます。これは、server（）関数のように機能するオートマトンになります。そのグラフを図1に示します。 1a。オートマトンアクションy1（）は、サーバーソケットを作成し、指定されたポートに接続します。述語x1（）はクライアント接続を定義し、存在する場合、y2（）アクションはクライアントソケットサービスプロセスを作成し、後者をアクティブオブジェクトクラスを含むクラスプロセスリストに配置します。

図では図１ｂは、個々のクライアントのモデルのグラフを示している。オートマトンは状態「0」にあるため、クライアントが情報を送信する準備ができているかどうかを判断し（述語x1（）-true）、状態「1」への遷移時にアクションy1（）内で応答を受信します。さらに、クライアントが情報を受信する準備ができている場合（x2（）はすでにtrueである必要があります）、アクションy2（）は、初期状態「0」への遷移時にクライアントにメッセージを送信する操作を実装します。クライアントがサーバーとの接続を切断すると（この場合、x3（）はfalse）、オートマトンは状態「4」に切り替わり、y3（）アクションでクライアントソケットを閉じます。プロセスは、アクティブなクラスのリストから除外されるまで「4」状態のままです（リストの形成については、サーバーモデルの上記の説明を参照してください）。

図では1cは、リスト1のevent_loop（）関数と同様のプロセスの起動を実装するオートマトンを示しています。この場合のみ、その操作アルゴリズムははるかに単純です。それはすべて、マシンがアクティブなクラスのリストの要素を調べて、それらのそれぞれに対してloop（）メソッドを呼び出すという事実に帰着します。このアクションはy2（）によって実装されます。 y4（）アクションは、状態「4」にあるクラスをリストから除外します。残りのアクションは、オブジェクトのリストのインデックスで機能します。y3（）アクションはインデックスを増やし、y1（）アクションはインデックスをリセットします。

Pythonのオブジェクトプログラミング機能は、C ++のオブジェクトプログラミングとは異なります。したがって、オートマトンモデルの最も単純な実装が基礎として使用されます（正確には、オートマトンの模倣です）。これは、プロセスを表すというオブジェクトの原則に基づいており、各プロセスは個別のアクティブクラスに対応します（エージェントとも呼ばれます）。このクラスには、必要なプロパティとメソッドが含まれ（特定のオートマトンメソッドの詳細- [9]の述語とアクションを参照）、オートマトン操作のロジック（遷移関数と終了関数）は、loop（）と呼ばれるメソッドのフレームワーク内に集中しています。オートマトンの動作のロジックを実装するために、if-elif-else構造を使用します。

このアプローチでは、「イベントループ」はソケットの可用性の分析とは何の関係もありません。それらは、述語内で同じselectステートメントを使用するプロセス自体によってチェックされます。この状況では、それらはリストではなく単一のソケットで動作し、この特定のソケットに期待される動作をチェックし、正確には動作アルゴリズムによって決定される状況で動作します。ちなみに、そのような実装をデバッグする過程で、selectステートメントの予期せぬブロッキングエッセンスが現れました。

図：1.ソケットを操作するための自動プロセスのグラフ

リスト2は、ソケットを操作するためのPythonのオートマトンオブジェクトコードを示しています。これは、私たちの一種の「コロチンのない世界」です。これは、ソフトウェアプロセスを設計するためのさまざまな原則を持つ「世界」です。これは、並列計算のアルゴリズムモデルの存在を特徴としています（詳細については、[9]を参照してください。これは、オートマトンプログラミングテクノロジ（AP）と「通常のテクノロジ」の主な定性的な違いです。

Automatonプログラミングは、プログラム設計、プロセスの並列処理、および同時にプログラマーの心が考えることができるすべての非同期原則を簡単に実装します。私の以前の記事では、自動計算の構造モデルの説明とそのアプリケーションの例への正式な定義から始めて、これをより詳細に説明しています。上記のPythonのコードは、コルーチンのコルーチン原則の自動実装を示しており、それらを完全にオーバーラップさせ、ステートマシンモデルで補足および拡張しています。

リスト2.マシン上のソケット

import socket
from select import select

timeout = 0.0; classes = []

class Server:
    def __init__(self): self.nState = 0;

    def x1(self):
        self.ready_client, _, _ = select([self.server_socket], [self.server_socket], [], timeout)
        return self.ready_client

    def y1(self):
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server_socket.bind(('localhost', 5001))
        self.server_socket.listen()
    def y2(self):
        self.client_socket, self.addr = self.server_socket.accept()
        print('Connection from', self.addr)
        classes.append(Client(self.client_socket, self.addr))

    def loop(self):
        if (self.nState == 0):      self.y1();      self.nState = 1
        elif (self.nState == 1):
            if (self.x1()):         self.y2();      self.nState = 0

class Client:
    def __init__(self, soc, adr): self.client_socket = soc; self.addr = adr; self.nState = 0

    def x1(self):
        self.ready_client, _, _ = select([self.client_socket], [], [], timeout)
        return self.ready_client
    def x2(self):
        _, self.write_client, _ = select([], [self.client_socket], [], timeout)
        return self.write_client
    def x3(self): return self.request

    def y1(self): self.request = self.client_socket.recv(4096);
    def y2(self): self.response = 'Hello World\n'.encode(); self.client_socket.send(self.response)
    def y3(self): self.client_socket.close(); print('close Client', self.addr)

    def loop(self):
        if (self.nState == 0):
            if (self.x1()):                     self.y1(); self.nState = 1
        elif (self.nState == 1):
            if (not self.x3()):                 self.y3(); self.nState = 4
            elif (self.x2() and self.x3()):     self.y2(); self.nState = 0

class EventLoop:
    def __init__(self): self.nState = 0; self.i = 0

    def x1(self): return self.i < len(classes)

    def y1(self): self.i = 0
    def y2(self): classes[self.i].loop()
    def y3(self): self.i += 1
    def y4(self):
        if (classes[self.i].nState == 4):
            classes.pop(self.i)
            self.i -= self.i

    def loop(self):
        if (self.nState == 0):
            if (not self.x1()): self.y1();
            if (self.x1()):     self.y2(); self.y4(); self.y3();

namSrv = Server(); namEv = EventLoop()
while True:
    namSrv.loop(); namEv.loop()

リスト2のコードは、リスト1のコードよりもはるかに技術的に進んでいます。これが、自動計算モデルのメリットです。これは、オートマトンの動作をプログラミングオブジェクトモデルに統合することで容易になります。その結果、オートマトンプロセスの動作のロジックは、生成された場所に正確に集中し、通常のようにプロセス制御のイベントループに委任されることはありません。新しいソリューションは、ユニバーサルな「イベントループ」の作成を引き起こします。そのプロトタイプは、EventLoopクラスのコードと見なすことができます。

4.SRPおよびDRYの原則について

「単一責任」の原則-SRP（単一責任原則）および「自分自身を繰り返さない」-DRY（自分自身を繰り返さない）は、OlegMolchanovによる別のビデオのコンテキストで表明されています[11]。彼らによると、関数には、SRYの原則に違反しないようにターゲットコードのみが含まれ、DRYの原則に違反しないように「追加コード」の繰り返しに寄与しないようにする必要があります。この目的のために、デコレータを使用することが提案されています。しかし、別の解決策があります-自動です。

前回の記事[2]そのような原則の存在に気づかずに、デコレータを使用して例が示されました。ちなみに、必要に応じてリストを生成できるカウンターを検討しました。カウンターの稼働時間を測定するストップウォッチオブジェクトについて説明します。オブジェクトがSRPおよびDRYの原則に準拠している場合、その機能は通信プロトコルほど重要ではありません。実装では、カウンターコードはストップウォッチコードとは関係がなく、オブジェクトのいずれかを変更しても他のオブジェクトには影響しません。それらはプロトコルによってのみ拘束され、オブジェクトは「海岸で」同意し、厳密にそれに従います。

したがって、並列オートマトンモデルは、基本的にデコレータの機能を上書きします。それらの機能を実装する方がより柔軟で簡単です。機能コードを「囲み」ません（装飾しません）。オートマトンと従来の技術の客観的な評価と比較を目的として、リスト3は、前の記事[2]で説明したカウンターのオブジェクトアナログを示しています。ここでは、実行時刻を含む簡略化されたバージョンと、カウンターの元のバージョンがコメントの後に示されています。

リスト3.自動カウンターの実装

import time
# 1) 110.66 sec
class PCount:
    def __init__(self, cnt ): self.n = cnt; self.nState = 0
    def x1(self): return self.n > 0
    def y1(self): self.n -=1
    def loop(self):
        if (self.nState == 0 and self.x1()):
            self.y1();
        elif (self.nState == 0 and not self.x1()):  self.nState = 4;

class PTimer:
    def __init__(self, p_count):
        self.st_time = time.time(); self.nState = 0; self.p_count = p_count
#    def x1(self): return self.p_count.nStat == 4 or self.p_count.nState == 4
    def x1(self): return self.p_count.nState == 4
    def y1(self):
        t = time.time() - self.st_time
        print ("speed CPU------%s---" % t)
    def loop(self):
       if (self.nState == 0 and self.x1()): self.y1(); self.nState = 1
       elif (self.nState == 1): pass

cnt1 = PCount(1000000)
cnt2 = PCount(10000)
tmr1 = PTimer(cnt1)
tmr2 = PTimer(cnt2)
# event loop
while True:
    cnt1.loop(); tmr1.loop()
    cnt2.loop(); tmr2.loop()

# # 2) 73.38 sec
# class PCount:
#     def __init__(self, cnt ): self.n = cnt; self.nState = 0
#     def loop(self):
#         if (self.nState == 0 and self.n > 0): self.n -= 1;
#         elif (self.nState == 0 and not self.n > 0):  self.nState = 4;
# 
# class PTimer:
#     def __init__(self): self.st_time = time.time(); self.nState = 0
#     def loop(self):
#        if (self.nState == 0 and cnt.nState == 4):
#            t = time.time() - self.st_time
#            print("speed CPU------%s---" % t)
#            self.nState = 1
#        elif (self.nState == 1): exit()
# 
# cnt = PCount(100000000)
# tmr = PTimer()
# while True:
#     cnt.loop();
#     tmr.loop()

# # 3) 35.14 sec
# class PCount:
#     def __init__(self, cnt ): self.n = cnt; self.nState = 0
#     def loop(self):
#         if (self.nState == 0 and self.n > 0):
#             self.n -= 1;
#             return True
#         elif (self.nState == 0 and not self.n > 0):  return False;
#
# cnt = PCount(100000000)
# st_time = time.time()
# while cnt.loop():
#     pass
# t = time.time() - st_time
# print("speed CPU------%s---" % t)

# # 4) 30.53 sec
# class PCount:
#     def __init__(self, cnt ): self.n = cnt; self.nState = 0
#     def loop(self):
#         while self.n > 0:
#             self.n -= 1;
#             return True
#         return False
#
# cnt = PCount(100000000)
# st_time = time.time()
# while cnt.loop():
#     pass
# t = time.time() - st_time
# print("speed CPU------%s---" % t)

# # 5) 18.27 sec
# class PCount:
#     def __init__(self, cnt ): self.n = cnt; self.nState = 0
#     def loop(self):
#         while self.n > 0:
#             self.n -= 1;
#         return False
# 
# cnt = PCount(100000000)
# st_time = time.time()
# while cnt.loop():
#     pass
# t = time.time() - st_time
# print("speed CPU------%s---" % t)

# # 6) 6.96 sec
# def count(n):
#   st_time = time.time()
#   while n > 0:
#     n -= 1
#   t = time.time() - st_time
#   print("speed CPU------%s---" % t)
#   return t
#
# def TestTime(fn, n):
#   def wrapper(*args):
#     tsum=0
#     st = time.time()
#     i=1
#     while (i<=n):
#       t = fn(*args)
#       tsum +=t
#       i +=1
#     return tsum
#   return wrapper
#
# test1 = TestTime(count, 2)
# tt = test1(100000000)
# print("Total ---%s seconds ---" % tt)

さまざまなオプションの稼働時間を表にまとめ、作業結果についてコメントしましょう。

クラシックオートマトンの実装-110.66秒
オートマトンメソッドなしのオートマトン実装-73.38秒
自動ストップウォッチなし-35.14
各反復で出力されている間のフォームのカウンター-30.53
ブロッキングサイクルのあるカウンター-18.27
デコレータ付きのオリジナルカウンター-6.96

自動カウンターモデルを完全に表す最初のオプション。カウンター自体とストップウォッチの実行時間が最も長くなります。自動技術の原理をあきらめることで、稼働時間を短縮することができます。これに従って、オプション2では、述語とアクションの呼び出しがそれらのコードに置き換えられます。このようにして、メソッド呼び出し演算子の時間を節約しました。これは非常に目立ちます。30秒以上、動作時間を短縮しました。

3番目のオプションでもう少し節約し、より単純なカウンター実装を作成しましたが、カウンターサイクルの各反復で終了しました（通常の操作の模倣）。カウンターの停止をなくすことで（オプション5参照）、カウンターの作業を大幅に削減しました。しかし同時に、私たちは通常の仕事の利点を失いました。オプション6-これは、デコレータがすでに繰り返されている元のカウンターであり、実行時間が最小です。ただし、オプション5と同様に、これはブロッキング実装であり、関数の通常の操作について説明する場合には適していません。

5。結論

オートマトンテクノロジーを使用するか、信頼できるルーチンを使用するかは、完全にプログラマーに決定されます。ここで私たちにとって重要なのは、プログラム設計には、通常のアプローチとは異なるアプローチ/テクノロジーがあることを彼が知っていることです。次のエキゾチックなオプションを想像することもできます。まず、モデル設計段階で、オートマトンソリューションモデルが作成されます。それは厳密に科学的で、証拠に基づいており、十分に文書化されています。次に、たとえば、パフォーマンスを向上させるために、リスト3に示すように、コードの「通常の」バージョンに「変形」されます。コードの「逆リファクタリング」を想像することもできます。 7番目のオプションから1番目のオプションへの移行ですが、これは可能ですが、イベントの可能性が最も低いコースです:)

図。 2は、トピック「非同期」に関するビデオのスライドを示しています[10]。..。そして、「悪い」は「良い」を上回っているようです。そして、私の意見では、オートマトンが常に優れている場合、非同期プログラミングの場合は、彼らが言うように、あなたの好みに合わせて選択してください。しかし、「悪い」オプションが最も可能性が高いようです。また、プログラマーは、プログラムを設計するときに、これについて事前に知っておく必要があります。

図：2.非同期プログラミングの特徴

確かに、オートマトンコードはやや「罪がないわけではない」。コードの量が少し多くなります。しかし、最初に、それはよりよく構造化されているので、理解しやすく、維持しやすいです。そして、第二に、それは常に大きくなるとは限りません。複雑さが増すにつれ、（たとえば、オートマトンメソッドの再利用により）さらに利益が得られる可能性があります。デバッグがより簡単で明確になります。はい、結局のところ、それは完全にSRPとDRYです。そして、これは時々、はるかに重要です。

たとえば、関数の設計の標準に注意を払うことが望ましく、おそらく必要ですらあります。プログラマーは、可能な限り、ブロッキング関数の設計を避ける必要があります。これを行うには、計算プロセスを開始するだけで、完全性がチェックされるか、例で検討されているselect関数のように開始の準備ができているかどうかをチェックする手段が必要です。リスト4に示すように、DOS時代にさかのぼる関数を使用するコードは、そのような問題には長い「ルーチン前」の履歴があることを示しています。

リスト4.キーボードから文字を読み取る

/*
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    int C=0;
    while (C != 'e')
    {
        C = getch();
        putchar (C);
    }
    return a.exec();
}
*/
//*
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    int C=0;
    while (C != 'e')
    {
        if (kbhit()) {
            C = getch();
            putch(C);
        }
    }

    return a.exec();
}
//*/

キーボードから文字を読み取るための2つのオプションがあります。最初のオプションはブロッキングです。計算をブロックし、getch（）関数がキーボードから文字を受け取るまで、ステートメントを実行して文字を出力しません。 2番目のバリアントでは、ペアの関数kbhit（）が文字が入力バッファーにあることを確認したときに、同じ関数が適切なタイミングでのみ起動されます。したがって、計算がブロックされることはありません。

関数自体が「重い」場合、つまり作業にはかなりの時間が必要であり、コルチンの作業の種類によって定期的に終了する（これは、同じコルチンのメカニズムを使用せずに実行できるため、バインドされないようにする）ことは困難であるか、あまり意味がありません。その場合、そのような機能を別のスレッドに配置してから、作業の完了を制御します（[2]のQCountクラスの実装を参照してください）。）。

計算のブロックを除外する方法をいつでも見つけることができます。上記では、coroutine / coroutineメカニズムや、VKP（a）自動プログラミング環境などの特殊な環境を使用せずに、言語の通常の手段のフレームワーク内で非同期コードを作成する方法を示しました。そして、何をどのように使用するかは、プログラマーが決定します。

文献

1.Pythonジュニアポッドキャスト。 pythonの非同期について。 [電子リソース]、アクセスモード：www.youtube.com/watch？v = Q2r76grtNeg、無料。言語。ロシア（治療日2020年7月13日）。

2.同時実行性と効率性：PythonとFSM。 [電子リソース]、アクセスモード：habr.com/ru/post/506604、無料。ヤズ。ロシア（治療日2020年7月13日）。

3. Molchanov O. Pythonの非同期の基礎＃4：ジェネレーターとラウンドロビンイベントループ。 [電子リソース]、アクセスモード：www.youtube.com/watch？v = PjZUSSkGLE8 ]、無料。言語。ロシア（治療日2020年7月13日）。

4.48のジェネレーターとイテレーター。 Pythonのジェネレータ式。 [電子リソース]、アクセスモード：www.youtube.com/watch？v = vn6bV6BYm7w、自由。ヤズ。ロシア（治療日2020年7月13日）。

5.メモ化とカレー（Python）。 [電子リソース]、アクセスモード：habr.com/ru/post/335866、無料。言語。ロシア（治療日2020年7月13日）。

6.リュブチェンコV.S.再帰への対処について。「PCワールド」、No.11 / 02。www.osp.ru/pcworld/2002/11/164417

7. Molchanov O. Python Cast＃10-歩留まりとは何ですか。 [電子リソース]、アクセスモード：www.youtube.com/watch？v = ZjaVrzOkpZk、無料。言語。ロシア（治療日2020年7月18日）。

8. Molchanov O. Pythonでの非同期の基礎＃5：ジェネレーターでの非同期。 [電子リソース]、アクセスモード：www.youtube.com/watch？v = hOP9bKeDOHs、無料。言語。ロシア（治療日2020年7月13日）。

9.並列コンピューティングモデル。[電子リソース]、アクセスモード：habr.com/ru/post/486622、無料。ヤズ。ロシア（治療日2020年7月20日）。

10. Polishchuk A.Pythonでの非同期。[電子リソース]、アクセスモード：www.youtube.com/watch？v = lIkA0TDX8tE、無料。ヤズ。ロシア（治療日2020年7月13日）。

11. Molchanov O.レッスンPythonキャスト＃6-デコレーター。[電子リソース]、アクセスモード：www.youtube.com/watch？v = Ss1M32pp5Ew、無料。言語。ロシア（治療日2020年7月13日）。

コルティンのない世界。ジェネレータイテレータ