プロセスとは何ですか?

プログラムは単独では実行できません。プログラムがメモリにロードされ、システムがリソースを割り当てた場合にのみ実行できます。この実行されたプログラムはプロセスと呼ばれます。プログラムとプロセスの違いは、プログラムは命令の集合であり、プロセスの静的な記述テキストであるのに対し、プロセスはプログラムの実行アクティビティであり、動的な概念であることです。

スレッドとは何ですか?

スレッドは、オペレーティングシステムが操作のスケジューリングを実行できる最小単位です。これはプロセスに含まれており、プロセス内の実際の操作単位となります。スレッドは、プロセス内の単一の順次制御フローを指します。プロセス内では複数のスレッドを同時に実行でき、各スレッドは異なるタスクを並行して実行します。

プロセスとスレッドの違いは何ですか?

スレッドはメモリ空間を共有し、プロセスのメモリは独立しています。

同じプロセスのスレッドは相互に直接通信できますが、2 つのプロセスは中間エージェントを介して相互に通信する必要があります。

新しいスレッドの作成は非常に簡単です。新しいプロセスを作成するには、その親プロセスを複製する必要があります。

スレッドは同じプロセス内の他のスレッドを制御および操作できますが、プロセスは子プロセスのみを操作できます。

Python GIL (グローバル インタプリタ ロック)

開いているスレッドの数や CPU の数に関係なく、Python は実行時に同時に 1 つのスレッドしか許可しません。

Pythonスレッドモジュール

直接呼び出し

1. インポートスレッド、時間
3. def run_num(num):
4. 」 ""
5. 定義スレッドによって実行される関数
6. :param num:
7. :return:
8. """
9. print("実行中番号:% s"%num)
10. time.sleep(3)
12. if __name__ == '__main__':
13. # 生成するスレッドインスタンス t1
14. t1 = threading.Thread(target=run_num,args=(1,))
15. # スレッドインスタンスを生成します t2
16. t2 = threading.Th read(target=run_num ,args=(2,))
17. # スレッドを開始 t1
18. t1.start()
19. # スレッドを開始t2
20. t2.start()
21. # スレッド名を取得します
出力:
番号: 1 で実行中
番号: 2 で実行中
25. インポートスレッド、時間
26. )
27. self. num = num
28. # 各スレッドで実行する関数を定義します。関数名は run である必要があります
29. def run (自分):
30. 番号: %s"%self.num)
31. time.sleep(3)
33. 場合 __name__ == '__main__':
34. t1 = MyThread (1)
35. t2 = MyThread(2)
36. t1.start()
37. t2 .start()
38. 出力:
39. 番号:1で実行中
40. 番号:2で実行中
41. 結合とデーモン
    参加
    の機能結合はメインプロセスをブロックするものであり、結合後のプログラムは実行できません。
42. マルチスレッドおよび複数の結合の場合、各スレッドの結合メソッドが順番に実行され、後続のスレッドが実行される前に前のスレッドの実行が完了します。
    パラメータがない場合は、スレッドの終了を待ってから後続のプログラムを実行します。
    パラメータを設定した後、スレッドが終了するかどうかに関係なく、スレッドで設定された時間待ってから、後続のメイン処理を実行します。
43. インポートスレッド、時間

MyThread(threading.Thread):

1. self,num):
2. .Thread.__init__ (自分)
3. self.num = num
4. (自分) :
5. print("スレッド:% s "%self.num)
7. if __name__ == '__main__':
8. t1 = MyThread(1)
9. t2 = 私のスレッド( 2 )
10. t1.start()
11. t1.join()
12. t2.start()
13. t2.join()
14. 番号: 1で実行中
15. スレッド:1番号:2 で実行中
16. t1 = MyThread(1)
17. t2 = MyThread(2)
18. t1.start()
t1.join(2 )
1. t2.start( )
2. t2.join()
3. 出力:
4. 番号:1
5. で走っています番号:2
6. スレッド: 1
7. スレッド:2
8. デーモン デフォルトでは、メインスレッドは終了時にすべての子スレッドの終了を待ちます。メインスレッドが子スレッドを待たずに、終了時にすべての子スレッドを自動的に終了するようにしたい場合は、子スレッドをバックグラウンドスレッド (デーモン) として設定する必要があります。方法はスレッドクラスのsetDaemon()メソッドを呼び出すことです。
9. インポート時間、スレッド
11. def run(n):
12. print("
    %s".center(20,") *
    ") %n)
time.sleep(2)
1. print("
done
2. ".center(20,"
   *
   "))
4. def main():
for
5. i
   in range(5):
6. t = threading.Thread(target=run,args=(i,))
   t.start()
8. t.join(1)
9. print("
   開始スレッド",t.getName())
10. m = threading.Thread(target=main,args=())
11. # メインスレッドをプログラムのメインスレッドのデーモンスレッドとして機能するデーモンスレッドに設定します。メインスレッドが終了すると、m によって開始された他のサブスレッドも、実行が完了したかどうかに関係なく終了します
12. m.setDaemon(True)
13. 。 m.start()
14. m.join(3)
15. print("メインスレッド完了".center(20,"*"))
16. 出力:
17. *********0**********
18. 開始スレッド Thread-2
19. ************ 1*** ******
20. **********完了************
21. スレッド開始 Thread-3
22. **** *****2**********
23. **メインスレッドが完了しました**

スレッドロック(ミューテックス)

1 つのプロセスが複数のスレッドを開始でき、複数のスレッドが親プロセスのメモリ空間を共有します。つまり、現時点では、2 つのスレッドが同じデータを同時に変更したい場合は、各スレッドが同じデータにアクセスできます。ロックが必要です。

1. インポート時間、スレッド
3. def addNum():
4. # 各スレッドでこのグローバル変数を取得します
5. グローバル番号
6. num -= 1
7. # 共有変数を設定します
8. num = 100
9. thread_list = []
10. のため i 範囲 (100):
11. t = threading.Thread(target=addNum)
12. t.start()
13. (て)
# すべてのスレッドの実行が完了するまで待ちます
15. for
    t in​​ thread_list:
16. t.join()
18. 印刷("final num:" ,num)
    ロックされたバージョン
19. Lock は、他のスレッドが共有リソースにアクセスすることをブロックし、同じスレッドが複数回取得した場合、デッドロックが発生し、プログラムの実行を続行できません。
インポート時間、スレッド
21. def addNum():

# 各スレッドでこのグローバル変数を取得します

1. グローバル番号
print("
3. --get num:
   ",num)
4. time.sleep(1)
5. # データを変更する前にロックします
6. lock.acquire()
7. # このパブリック変数に対して -1 操作を実行します
8. 番号 -= 1
9. # 変更後のリリース
10. lock.release()
11. # 共有変数を設定します
12. 番号 = 100
13. thread_list = [ ]
14. # グローバルロックを生成
15. lock = threading.Lock()
16. for i 範囲内(100):
17. t = threading.Thread(target=addNum)
18. t.start()
19. thread_list.append(t)
20. # すべてのスレッドが完了するまで待ちます完了
21. forin thread_list:
22. t.join()
24. print("
    最終番号:",num)
GIL VS Lock

GIL は、同時に 1 つのスレッドのみが実行できることを保証します。ロックはユーザーレベルのロックであり、GIL とは関係ありません。

RLock (再帰的ロック)

Rlock は、同じスレッド内で複数回取得できるようにします。スレッドによる共有リソースの解放には、すべてのロックの解放が必要です。つまり、n 回の取得には n 回のリリースが必要になります。

1. def run1():
print("
2. 最初の部分データを取得
   ")
3. lock
   .acquire()
グローバル番号
num += 1
6. lock
   .release()
7. return
   num
def run2():
print("
10. 後半データを取得
    ")
11. lock
    .acquire()
global num2
num2 += 1
14. lock
    .release()
15. return
    num2
17. def run3():
18. lock.acquire()
19. res = run1()
20. print("run1 とrun2".center(50,"*"))
21. res2 = run2()
22. lock.release()
23. print(res,res2 )
25. if __name__ == '__main__':
26. num,num2 = 0,0
27. lock = threading.RLock()
28. fori範囲(10):
29. t = threading.Thread(target=run3)
30. t.start()
32. while threading.active_count() != 1:
33. print(threading.active_count())
34. else:
35. print("すべてのスレッドが完了しました".center(50,"*"))
36. print(num,num2)
この二つの锁の主要区は、RLock允许が同一回線中に存在しますただし、ロックではこのような状況は許可されません。RLock を使用する場合は、取得と解放を行う必要があります。つまり、n 回取得し、実際に使用されているロックを解放するには、n 回の解放を行う必要があります。

Semaphore（信号量）

相互接続は同時に1つの回線変更データを許可しますが、Semaphoreは同時に一定数の回線変更データを許可します。

インポートスレッド、時間
def run(n):
セマフォ.acquire( )
4. time.sleep(1)
5. print("
スレッドを実行します:%s
6. "%n)
   semaphore( )
if
9. __name__ == '__main__':
   # 最多允许5个線程同時進行
10. セマフォre = threading.BoundedSemaphore(5)
for
12. 私は
    範囲内(20):
13. t = threading.Thread(target=run,args=(i,))
14. t.start()
16. while _count() != 1:
17. # print(threading.active_count())
18. # pass
19. else:
20. print("すべてのスレッドが完了しました ".center(50,"*"))
Timer (タイマー)
タイマーは一定の間隔で関数を呼び出します。一定の間隔で関数を呼び出したい場合は、次の関数を呼び出す必要がありますタイマー機能でタイマーを再設定します。 Timer は Thread の派生クラスです。
1. インポートスレッド
3. def hello():
4. print("hello, world!")
5. # 5 秒後の遅延hello関数を実行
6. t = threading.Timer(5,hello)
7. t.start()
Event
Pythonはスレッド間通信用のEventオブジェクトを提供します。これはスレッドによって設定されるシグナル フラグです。シグナル フラグ ビットが false の場合、スレッドは他のスレッドによって命令シグナルが true に設定されるのを待ちます。 Event オブジェクトは、スレッド間の通信を実現するための、シグナルの設定、シグナルのクリア、待機などの単純なスレッド通信メカニズムを実装します。
1. シグナルを設定する

Event の set() メソッドを使用して、Event オブジェクト内のシグナル フラグを true に設定します。 Event オブジェクトは、内部信号フラグの状態を決定するための isSet() メソッドを提供します。イベント オブジェクトの set() メソッドが使用されると、isSet() メソッドは true を返します。
1. シグナルをクリアする

Event オブジェクト内のシグナルフラグをクリアするには、Event の clear() メソッドを使用します。つまり、Event の clear() メソッドを使用すると、isSet が false に設定されます。 () メソッドは false を返します。
1. Waiting

Event の wait() メソッドは、内部シグナルが true の場合にのみ実行され、すぐに戻りを完了します。 Event オブジェクトの内部シグナル フラグが false の場合、wait() メソッドはそれが true になるまで待機してから戻ります。
イベントを使用して、2 つ以上のスレッド間の対話を実現します。信号機を例に挙げます。つまり、信号機として機能するスレッドを開始し、車両として機能する複数のスレッドを生成すると、車両はそれに応じて走行します。赤の停止と緑のルールに従う。
1. インポートスレッド、時間、ランダム
3. def light():
4. イベントではない場合。 isSet():
5. if
   count print ("
6. elif カウント
7. print(" 33[43;1m--黄色信号点灯-- 33[0m".center(50,"*"))
8. エリフ数 < ; 13:
9. ifevent.isSet():
10. event.clear()
11. print(" 33[41;1m--redライトオン -- 33[0m".center(50,"*"))
12. else:
13. count = 0
14. イベント。 set()
15. time.sleep(1)
16. count += 1
19. def car(n):
20. while 1:
21. time.sleep(random.randrange(10))
22. if event.isSet():
23. print( 「car％sが実行されています...」 n)
if
25. __name__ == "
    __main__":
26. event
    = threading.Event()
27. ライト = スレッド。スレッド(target=light,)
28. Light.start()
29. for
    i
in
30. range(3):
31. t = threading.Thread (target=car,args=(i,))
32. t.start()

    キュー queue

    Python のキューは、スレッド間でデータを交換する最も一般的に使用される形式です。 Queueモジュールはキュー操作を提供するモジュールです。

    キューオブジェクトを作成する

    1. インポートキュー
    3. q = queue.Queue(maxsize = 10)

    queueクラスはキューです同期を実現します。キューの長さは無制限にすることも、制限することもできます。キューの長さは、Queue コンストラクターのオプションのパラメーター maxsize を通じて設定できます。 maxsize が 1 未満の場合、キューの長さは無制限になります。

    キューに値を入れる

    1. q.put("a")

    キューオブジェクトの put() メソッドを呼び出して、キューの最後に項目を挿入します。 put() には 2 つのパラメータがあります。最初の項目は必須で、挿入された項目の値です。2 番目のブロックはオプションのパラメータで、デフォルトは 1 です。キューが現在空でブロックが 1 の場合、put() メソッドにより、データ ユニットが解放されるまで呼び出しスレッドが一時停止します。 block が 0 の場合、put() メソッドは完全な例外をスローします。

    キューから値を削除する

    1. q.get()

    キューオブジェクトのget()メソッドを呼び出して、キューの先頭から項目を削除して返します。オプションのパラメータは block で、デフォルトは True です。キューが空で、ブロックが True の場合、get() により、項目が使用可能になるまで呼び出しスレッドが一時停止します。キューが空でブロックが False の場合、キューは Empty 例外をスローします。

    Python Queue モジュールには 3 つのキューとコンストラクターがあります

    1. # 先入れ先出し
    2. class queue.Queue(maxsize=0)
    3. # 先入れ後出し
    4. class queue.LifoQueue(maxsize=0)
    5. # 優先キューレベルが低いほど、最初に出力されます
    6. class queue.Pri orityQueue(最大サイズ=0)

    共通メソッド

    1. q = queue.Queue()
    2. # キューのサイズを返す
    3. q.qsize()
    4. # キューが空の場合は True を返し、それ以外の場合は False を返します
    5. q.empty()
    6. # キューが空の場合は True を返し、それ以外の場合は False を返します
    7. q .full()
    8. # キューを取得、タイムアウト待ち時間
    9. q.get([block[,timeout]])
    10. # q.と同等get(False)
    11. q.get_nowait()
    12. # 他の操作を実行する前にキューが空になるまで待ちます
    13. q.join()

    プロデューサー/コンシューマー モデル

    開発とプログラミングでプロデューサーとコンシューマーのパターンを使用すると、ほとんどの同時実行の問題を解決できます。このモードは、プロダクション スレッドとコンシューマ スレッドの作業能力のバランスをとることにより、プログラムの全体的なデータ処理速度を向上させます。

    プロデューサーとコンシューマー モデルを使用する理由

    スレッドの世界では、プロデューサーはデータを生成するスレッドであり、コンシューマーはデータを消費するスレッドです。マルチスレッド開発では、プロデューサーの処理速度が非常に速く、コンシューマーの処理速度が非常に遅い場合、プロデューサーは、データの生成を続ける前にコンシューマーの処理が完了するのを待つ必要があります。同様に、コンシューマの処理能力がプロデューサの処理能力よりも優れている場合、コンシューマはプロデューサを待つ必要があります。この問題を解決するために、プロデューサー モデルとコンシューマー モデルが導入されました。

    プロデューサー-コンシューマー パターンとは何ですか?

    プロデューサー-コンシューマー パターンは、コンテナを使用してプロデューサーとコンシューマーの間の強い結合の問題を解決します。プロデューサーとコンシューマーは相互に直接通信するのではなく、ブロッキング キューを介して通信します。そのため、プロデューサーはデータを生成した後、コンシューマーがデータを処理するのを待つことなく、それをブロッキング キューに直接スローしません。プロデューサーにデータを要求しますが、ブロッキング キューから直接データを取得します。ブロッキング キューはバッファーに相当し、プロデューサーとコンシューマーの処理能力のバランスをとります。

    生産者-消費者モデルの最も基本的な例。

    1. インポートキュー、スレッド、時間
    3. q = queue.Queue(maxsize=10)
    5. defプロデューサー():
    6. カウント = 1
    7. while True:
    8. q.put("bone %s"%count)
    9. print(" 生成された骨 " ,count)
    10. count += 1
    12. def Consumer(name):
    13. while q.qsize() > 0:
        印刷("%[%s] は [%s] を取得して食べます...
    "%(name, q.
    14. get
        ())) time.sleep ( 1)
    16. p = threading.Thread(target=生産者,)
    17. c1 = threading.Thread(target=消費者,args=("
        豊かな富
    ",) )
    18. c2 = threading.Thread(target=Consumer,args=("
        来福
    ",))
    19. p.start()
    20. c1.start( )
    21. c2.start()