Pythonマルチスレッド-スレッドとスレッドの同期、タイミングスケジューリング（タイミングタスク）

_threadと比較して、スレッド化はカプセル化と関数拡張の度合いが高く、ユーザーにとってよりシンプルで便利です。

import threading,time
# 蒂尼多
def thread_handle(delay):
    for num in range(10):
        # 追加一个延时操作
        time.sleep(delay);
        print("{},num = {}".format(threading.currentThread().name,num));

def main():
    for item in range(10):
        # 创建一个新的线程对象，设置好该线程对象的处理函数以及参数内容，并且配置好线程名称
        thread = threading.Thread(target=thread_handle,args=(1,),name="执行线程 - {}".format(item))
        thread.start();
    time.sleep(200);

if __name__ == '__main__':
    main();

印刷用のアクティブなスレッドの数は、11、メインスレッド、および10の子スレッドになります。

import threading,time
# 蒂尼多
def thread_handle(delay):
    for num in range(10):
        # 追加一个延时操作
        time.sleep(delay);
        print("{},num = {}".format(threading.currentThread().name,num));

def main():
    for item in range(10):
        # 创建一个新的线程对象，设置好该线程对象的处理函数以及参数内容，并且配置好线程名称
        thread = threading.Thread(target=thread_handle,args=(1,),name="执行线程 - {}".format(item))
        thread.start();
    time.sleep(1);
    print("主线程ID：{},主线程名称：{}".format(threading.current_thread().ident, threading.current_thread().name));
    print("当前活跃线程个数：{}".format(threading.active_count()));
    print("当前活跃线程信息：{}".format(threading.enumerate()));
if __name__ == '__main__':
    main();

マルチスレッドにオブジェクト指向のアプローチを使用する

import threading,time
class MyThread(threading.Thread):
    def __init__(self,thread_name,delay):
        # 将线程名字传递到父类构造
        super().__init__(name = thread_name);
        # 保存延迟时间
        self._delay = delay;
    def run(self):
        for num in range(5):
            # 线程执行延迟
            time.sleep(self._delay);
            print("{},num = {}".format(threading.current_thread().getName(),num));

def main():
    for item in range(10):
        # 创建一个新的线程对象，设置好该线程对象的处理函数以及参数内容，并且配置好线程名称
        thread = MyThread("执行线程：{}".format(item),1)
        thread.start();
if __name__ == '__main__':
    main();

スレッドの同期

import threading,time

# 定义银行的处理业务
def bank_handle(semaphore):
    # 尝试获取信号量，如果没有获取就等待
    if semaphore.acquire():
        print("{},资源抢占成功，开始办理个人相关业务".format(threading.current_thread().name));
        # 模拟业务办理时间
        time.sleep(2);
        # 释放锁定
        semaphore.release();

def main():
    semaphore = threading.Semaphore(2);
    thread_list = [threading.Thread(target=bank_handle,args=(semaphore,),name="银行客户：{}".format(item)) for item in range(10)];
    for item in thread_list:
        item.start();

if __name__ == '__main__':
    main();

Pythonの従来のスレッド同期メカニズムはロックを使用してロックしますが、繰り返しロックが解除されない場合、デッドロックが発生します。この問題を解決するために、PythonはRLockを提供します。これの利点は、ロックが何度追加されても、一度使用できます。セックスロック解除。

import threading,time
ticket = 3;
# 定义银行的处理业务
def sale(lock):
    # 尝试获取信号量，如果没有获取就等待
    if lock.acquire():
        global ticket;
        if ticket > 0:
            time.sleep(1);
            ticket -= 1;
            print("{}卖票,剩余票数为:{}".format(threading.current_thread().name,ticket));
        # 释放锁定
        lock.release();

def main():
    lock = threading.RLock();
    thread_list = [threading.Thread(target=sale,args=(lock,),name="银行客户：{}".format(item)) for item in range(10)];
    for item in thread_list:
        item.start();

if __name__ == '__main__':
    main();

タイミングスケジューリング

import threading,time,sched
ticket = 3;
# 定义银行的处理业务
def event_handle(schedule):
    print("{}奥特曼".format(threading.current_thread().name));
    # delay延迟1秒，priority优先级，action执行函数,argument传递参数
    schedule.enter(delay=1,priority=0,action=event_handle,argument=(schedule,));

def main():
    # 创建定时调度
    schedule = sched.scheduler();
    schedule.enter(delay=0,priority=0,action=event_handle,argument=(schedule,));
    schedule.run();

if __name__ == '__main__':
    main();