Python でのマルチスレッド (概要)

この記事では、Python に関する関連知識を提供します。主にマルチスレッドに関する関連コンテンツを紹介します。同じプログラム内で複数のスレッドを実行でき、各スレッドは完了します。さまざまなタスクを見てみましょう皆様のお役に立てれば幸いです。

#[関連する推奨事項:

Python3 ビデオ チュートリアル]

Python マルチスレッド

1. スレッドの概念

スレッドは、CPU がリソースを割り当てるための基本単位です。プログラムが実行を開始すると、プログラムはプロセスになり、プロセスは 1 つ以上のスレッドに相当します。マルチスレッド プログラミングがない場合、プロセスはメイン スレッドに相当しますが、マルチスレッド プログラミングがある場合、プロセスには複数のスレッド (メイン スレッドを含む) が含まれます。大規模なプログラム開発はスレッドを使用して実現できます。

同じプログラム内で複数のスレッドを実行でき、各スレッドは異なるタスクを完了します。

マルチスレッドのバックグラウンド サービス プログラムは、ブロックすることなく複数のタスクを同時に処理できます。

マルチスレッドプログラミングの特徴は、プログラムの実行効率や処理速度を向上できることです。 Python プログラムは、複数の比較的独立したスレッドを同時に並行して実行できます。

2. マルチスレッドの作成

Python は、マルチスレッドを作成する 2 つの方法をサポートしています:

~threading.Thread () によって作成。

~threading.Thread クラスを継承することによって。

1. threading.Thread () で作成します

文法形式:

thread.Thread(group=Nore,targt=None,args=(),kwargs={},*,daemon=None)

パラメータの説明:

~group: None である必要があります。ThreadGroup クラスに関連しており、通常は使用されません。

~target: スレッドによって呼び出されるオブジェクトはターゲット関数です。

~name: スレッドにこの名前を付けます。デフォルトは Tread-x です。x は 1 から始まるシリアル番号で、最初に作成されるスレッドの名前は Tread-1 です。

~args: キーワード引数と辞書をターゲット関数に渡します。

~daemon: メインスレッドの終了時にスレッドも終了するかどうかを設定するために使用されます。

例:

import threading
def test (x,y):
 for i in range(x,y):
   print(i)
thread1 = threading.Thread(name='t1',target= test,args=(1,10))
thread2 = threading.Thread(name='t2',target= test,args=(11,20))
thread1.start()   #启动线程1
thread2.start()   #启动线程2

出力:

1
2
3
4
5
6
7
8
9
11
12
13
14
15
16
17
18
19

説明: 2 つのプログラムは同時に実行されるため、結果は毎回 1 ～ 10 で連続するわけではありません。 CPU は 2 つのスレッドに時間セグメントを割り当てます。毎回結果が異なることがわかります。

2. threading.Thread クラスの継承

threading.Thread はクラスであり、継承できます。

例:

import threading
class mythread(threading.Thread):
  def run(self):
    for i in range(1,10):
      print(i)
thread1 = mythread();
thread2 = mythread();
thread1.start()
thread2.start()

出力:

1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

説明: threading.Thread を継承するようにクラスをカスタマイズし、親クラスの run メソッドをオーバーライドします。 (execute start()) は、このメソッドを自動的に実行します。

3. メインスレッド

Python では、メインスレッドは最初に開始されるスレッドです。

~親スレッド: 開始スレッド A でスレッド B が開始された場合、A は B の親スレッドです。

~サブスレッド: B は A のサブスレッドです。

スレッドを作成するときに、メイン スレッドを決定するために使用される damon 属性があります。デーモンが False に設定されている場合、メイン スレッドが終了してもスレッドは終了せず、メイン スレッドは子スレッドの実行が完了するまで待機します。デーモンが True に設定されている場合、メイン スレッドの終了時にスレッドも終了し、メイン スレッドの終了時に他の子スレッドも強制的に終了します。

デーモンを使用する場合の注意:

~デーモン属性は start() の前に設定する必要があります。そうしないと、RuntimeError 例外が発生します。

~各スレッドにはデーモン属性があります。明示的に設定できます。設定できない場合もあります。設定されていない場合、デフォルト値は Noneです。

~サブサブスレッドがデーモン属性を設定していない場合は、現在のスレッドのデーモンを取得して設定しますそれ。子スレッドは子スレッドのデーモン値を継承します。これは、None を設定するのと同じ効果があります。

~メイン スレッドから作成されたすべてのスレッドはデーモン属性を設定せず、デフォルトは daemon=False です。

例:

import time
import threading
def test():
 time.sleep(10)
 for i in range(10):
  print(i)
thread1 = threading.Thread(target=test,daemon=False)
thread1.start()
print('主线程完成了')

出力:

主线程完成了
0
1
2
3
4
5
6
7
8
9

説明: メインスレッドの実行が終了して出力したら、しばらく待ってから 0 ～ 9 を出力します。 daemon=False が daemon=True に変更された場合、for i in range(10) ステートメントは実行されません。

4. スレッドのブロック

スレッドが別のスレッドの join メソッドを呼び出すと、呼び出し元のスレッドが終了するまで呼び出し元はブロックされます。

文法形式:

join(timeout-=None)

タイムアウト パラメータは、呼び出し側の待機時間を指定します。設定されていない場合、呼び出されたスレッドが終了するまで待機します。このうち、スレッドは join によって複数回呼び出すことができます。

例:

import time
import threading
def test():
 time.sleep(5)
 for i in range(10):
  print(i)
thread1=threading.Thread(target=test)
thread1.start()
thread1.join()
print('主线程完成了')

出力:

0
1
2
3
4
5
6
7
8
9
主线程完成了

説明: thread1.start() の後に thread1.join() を追加して join メソッドを追加します。独自の印刷出力を実行する前に、0 ～ 9 が出力されるまで待機します。

5. スレッドがアクティブかどうかを確認します

~run(): スレッドのアクティビティを示すために使用されるメソッド

~start(): スレッドを開始します。 thread

~join(): スレッドが終了するまで待機します

~isAlive(): スレッドがアクティブかどうかを返します

~getName(): スレッド名を返します

~setName(): スレッド名を設定します

例:

from threading import Thread, Event
import time
def countdown(n, started_evt):
    print('正在运行')
    started_evt.set()
    while n > 0:
        print('时间', n)
        n -= 1
        time.sleep(2)
started_evt = Event()
print('开始倒计时')
t = Thread(target=countdown, args=(10, started_evt))
t.start()
started_evt.wait()
print('倒计时运行')

出力:

开始倒计时
正在运行
时间 10
倒计时运行
时间 9
时间 8
时间 7
时间 6
时间 5
时间 4
时间 3
时间 2
时间 1

Alive，顾名思义，它表示线程当前是否为可用状态，如果线程已经启动，并且当前没有任何异常的话，则返回true，否则为false

Thread.isAlive() ：顾名思义，是表示当前线程时候为可用状态，即是否已经在启动，并且在运行的状态；

六、线程同步

1.同步概念

异步模式的情况下，同时有一个线程在修改共享数据，另一个线程在读取共享数据，当修改的共享数据的线程没有处理完毕，读取数据的线程肯定会得到错误的结果。如果采用多线程的同步控制机制，当处理共享数据的线程完成处理数据之后，读取线程就读取数据。

python的锁就解决这一问题，锁住线程，只允许一个线程操作，其他线程排队等待，待当前线程操作完毕后，再按顺序一个一个来运行。

2. python的锁

python的threading模块提供了RLock锁解决方法。在某一时间只能让一个线程操作的语句放到RLock的acquire方法和release方法之间，即acquire相当于给RLack上锁，而release相当于解锁。

示例：

import threading
class mythread(threading.Thread):
 def run(self):
  global x                   #声明一个全局变量
  lock.acquire()             #上锁
  x +=10
  print('%s:%d'%(self.name,x))
  lock.release()             #解锁
x = 0                        #设置全局变量初始值
lock = threading.RLock()     #创建可重入锁
list1 = []                   
for i in range(5):   
 list1.append(mythread())    #创建五个线程，放到同一列表中
for i in list1:
 i.start()                   #开启列表线程

输出：

Thread-1:10
Thread-2:20
Thread-3:30
Thread-4:40
Thread-5:50

解释：

3. python中的条件锁

条件锁常用的方法：

~acquire([timeout]):调用关联锁的方法

~release()：解锁

~wait():使线程进入 Condition 的等待池等待通知并释放解锁。使用前线程必须已获得锁定，否则将抛出异常。

~notify():从等待池挑选一个线程并通知，收到通知的线程将自动调用 acquire() 尝试获得，其他线程仍然在等待池中等待通知，直到该线程收到通知 调用该方法，否则将会抛出异常。

~notify ALL():跟notify() 一样，但这个方法对应的是所有的线程。

示例：

题目：有几个生产车间生产，几个消费者购买，当生产达到一定数量时，停止生产。

import threading
import time
condtion = threading.Condition()
sheep = ['1件产品','1件产品','1件产品','1件产品','1件产品']
class Producer(threading.Thread):
    def __init__(self, name):
        super().__init__(name=name)
        pass
    def run(self):
        global condtion, sheep
        while True:
            time.sleep(0.1)
            condtion.acquire()
            if len(sheep) < 10:
                print(self.name + "生产了1件产品")
                sheep.append(&#39;1件产品&#39;)
                condtion.notifyAll()
                pass
            else:
                print("仓库满了，停止生产!")
                condtion.wait()
                pass
            condtion.release()
        pass
    pass
class Customer(threading.Thread):
    def __init__(self, name):
        super().__init__(name=name)
        pass
    def run(self):
        global condtion, sheep
        while True:
            time.sleep(0.1)
            condtion.acquire()
            if len(sheep) > 0:
                meat = sheep.pop()
                print(self.name + "购买了" + meat + "还剩多少" + str(len(sheep)) + "件")
                condtion.notifyAll()
                pass
            else:
                print("买光了，等待")
                condtion.wait()
                pass
            condtion.release()
        pass
    pass
if __name__ == "__main__":
    p1 = Producer("1号生产车间")
    p2 = Producer("2号生产车间")
    p3 = Producer("3号生产车间")
    p4 = Producer("4号生产车间")
    p5 = Producer("5号生产车间")
    p6 = Producer("6号生产车间")
    p1.start()
    p2.start()
    p4.start()
    p5.start()
    p6.start()
    c1 = Customer('小王')
    c2 = Customer('小李')
    c3 = Customer('小贾')
    c4 = Customer('小沈')
    c5 = Customer('小刘')
    c1.start()
    c2.start()
    c3.start()
    c4.start()
    c5.start()

【相关推荐：Python3视频教程 】

以上がPython でのマルチスレッド (概要)の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。