【Python】thread使用

1、Condition条件变量使用

# encoding:utf-8
'''Condition 提供了一种多线程通信机制，
假如线程 1 需要数据，那么线程 1 就阻塞等待，
这时线程 2 就去制造数据，线程 2 制造好数据后，
通知线程 1 可以去取数据了，然后线程 1 去获取数据。'''
import threading
import time
con = threading.Condition()
meat_num = 0

def thread_consumers():  # 条件变量 condition 线程上锁
    con.acquire()
    # 全局变量声明关键字 global
    global meat_num
    # 等待肉片下锅煮熟
    con.wait()
    while True:
        print("我来一块肉片...")
        meat_num -= 1
        print("剩余肉片数量：%d" % meat_num)
        time.sleep(0.5)
        if meat_num == 0:
            #  肉片吃光了，通知老板添加肉片
            print("老板，再来一份老肉片...")
            con.notify()
            #  肉片吃光了，等待肉片
            con.wait()
    # 条件变量 condition 线程释放锁
    con.release()
 
 
def thread_producer():  # 条件变量 condition 线程上锁
    con.acquire()  # 全局变量声明关键字 global
    global meat_num
    # 肉片熟了，可以开始吃了
    
    meat_num = 10
    print("肉片熟了，可以开始吃了...")
    con.notify()
    while True:
        #  阻塞函数,等待肉片吃完的通知
        con.wait()
        meat_num = 10
        #  添加肉片完成，可以继续开吃
        print("添加肉片成功！当前肉片数量：%d" % meat_num)
        time.sleep(1)
        con.notify()
    con.release()
 
if __name__ == '__main__':
    t1 = threading.Thread(target=thread_producer)
    t2 = threading.Thread(target=thread_consumers)
    # 启动线程 -- 注意线程启动顺序，启动顺序很重要
    t2.start()
    t1.start()
    # 阻塞主线程，等待子线程结束
    t1.join()
    t2.join()
 
print("程序结束！")
 
'''
输出结果：
肉片熟了，可以开始吃了...
我来一块肉片...
剩余肉片数量：9
我来一块肉片...
剩余肉片数量：8
我来一块肉片...
剩余肉片数量：7
我来一块肉片...
剩余肉片数量：6
我来一块肉片...
剩余肉片数量：5
我来一块肉片...
剩余肉片数量：4
我来一块肉片...
剩余肉片数量：3
我来一块肉片...
剩余肉片数量：2
我来一块肉片...
剩余肉片数量：1
我来一块肉片...
剩余肉片数量：0
老板，再来一份老肉片...
添加肉片成功！当前肉片数量：10
我来一块肉片...
剩余肉片数量：9
我来一块肉片...
剩余肉片数量：8
我来一块肉片...
剩余肉片数量：7
.............
'''

2、event通信

# encoding:utf-8
"""用于线程间的通信，藉由发送线程设置的信号，
若信号为True，其他等待的线程接受到信好后会被唤醒。
提供 設置信号 event.set(), 等待信号event.wait(), 清除信号 event.clear() 。"""

import threading
import time
def thread_first_job():
    global a
    # 线程进入等待状态
    print("Wait…")
    event.wait()
 
    for _ in range(3):
        a += 1
        print("This is the first thread ", a)
a = 0
# 创建event对象
event = threading.Event()
first_thread = threading.Thread(target=thread_first_job)
first_thread.start()
time.sleep(3)
# 唤醒处于等待状态的线程
print("Wake up the thread…")
event.set()
first_thread.join()
# ====== output ======
# Wait...
# Wake up the thread...
# This is the first thread  1
# This is the first thread  2
# This is the first thread  3

3、Semaphore信号量使用

# encoding:utf-8
# -*- coding:utf-8 -*-
import threading
import time
# Semaphore 跟 Lock 类似，但 Semaphore 多了计数器的功能，可以指定允许个数的线程同时执行。

sem = threading.Semaphore(3)
 
class DemoThread(threading.Thread):
 
    def run(self):
        print('{0} is waiting semaphore.'.format(self.name))
        sem.acquire()
        print('{0} acquired semaphore({1}).'.format(self.name, time.ctime()))
        time.sleep(5)
        print('{0} release semaphore.'.format(self.name))
        sem.release()
 
 
if __name__ == '__main__':
    threads = []
    for i in range(4):
        threads.append(DemoThread(name='Thread-' + str(i)))
 
    for t in threads:
        t.start()
 
    for t in threads:
        t.join()

4、setDaemon设置守护线程

"""若希望在主线程执行完毕后，
不管其他的Thread是否已执行完毕，
都强制跟主线程一起结束，
setDaemon()必须写在start() 之前，预设为 False。"""


import time
import threading

def test():
    while True:
        print(threading.currentThread())
        time.sleep(1)

if __name__ == '__main__':
    t1 = threading.Thread(target=test)
    t1.setDaemon(True)
    t1.start()

    t2 = threading.Thread(target=test)
    t2.setDaemon(True)
    t2.start()

5、threadPool_map使用

# encoding:utf-8
# 线程池可以控制并发多线程的数量,不会导致系统崩溃

from concurrent.futures import ThreadPoolExecutor
import threading
import time

# 定义一个准备作为线程任务的函数
def action(max):
    my_sum = 0
    for i in range(max):
        print(threading.current_thread().name + '  ' + str(i))
        my_sum += i
    return my_sum

# 创建一个包含2条线程的线程池
# pool = ThreadPoolExecutor(max_workers=2)
# # 向线程池提交一个task, 50会作为action()函数的参数
# future1 = pool.submit(action, 50)
# # 向线程池再提交一个task, 100会作为action()函数的参数
# future2 = pool.submit(action, 100)
# # 判断future1代表的任务是否结束
# print(future1.done())
# time.sleep(3)
# # 判断future2代表的任务是否结束
# print(future2.done())
# # 查看future1代表的任务返回的结果 阻塞
# print(future1.result())
# # 查看future2代表的任务返回的结果 阻塞
# print(future2.result())
# # 关闭线程池
# pool.shutdown()

# ancel()：取消该 Future 代表的线程任务。如果该任务正在执行，不可取消，则该方法返回 False；否则，程序会取消该任务，并返回 True。
# cancelled()：返回 Future 代表的线程任务是否被成功取消。
# running()：如果该 Future 代表的线程任务正在执行、不可被取消，该方法返回 True。
# done()：如果该 Funture 代表的线程任务被成功取消或执行完成，则该方法返回 True。
# result(timeout=None)：获取该 Future 代表的线程任务最后返回的结果。如果 Future 代表的线程任务还未完成，该方法将会阻塞当前线程，其中 timeout 参数指定最多阻塞多少秒。
# exception(timeout=None)：获取该 Future 代表的线程任务所引发的异常。如果该任务成功完成，没有异常，则该方法返回 None。
# add_done_callback(fn)：为该 Future 代表的线程任务注册一个“回调函数”，当该任务成功完成时，程序会自动触发该 fn 函数。
# 如果程序不希望直接调用 result() 方法阻塞线程，则可通过 Future 的 add_done_callback() 方法来添加回调函数，该回调函数形如 fn(future)。当线程任务完成后，程序会自动触发该回调函数，并将对应的 Future 对象作为参数传给该回调函数。
def spider(page):
    time.sleep(page)
    print(f"crawl task{page} finished  tread_name"+threading.currentThread().name)
    return page
# 该方法的功能类似于全局函数 map()，区别在于线程池的 map() 方法会为 iterables 的每个元素启动一个线程，以并发方式来执行 func 函数。这种方式相当于启动 len(iterables) 个线程，井收集每个线程的执行结果。
with ThreadPoolExecutor(max_workers=2) as pool:
    # map可以保证输出的顺序, submit输出的顺序是乱的.
    print ("start processes...")
    res = pool.map(spider, [0, 1, 2, 3])
    print("{}" .format(res))
    print('------done------')

6、threadPool使用

# encoding:utf-8
# 线程池可以控制并发多线程的数量,不会导致系统崩溃

from concurrent.futures import ThreadPoolExecutor
import threading
import time

# 定义一个准备作为线程任务的函数
def action(max):
    my_sum = 0
    for i in range(max):
        print(threading.current_thread().name + '  ' + str(i))
        my_sum += i
    return my_sum

# 创建一个包含2条线程的线程池
# pool = ThreadPoolExecutor(max_workers=2)
# # 向线程池提交一个task, 50会作为action()函数的参数
# future1 = pool.submit(action, 50)
# # 向线程池再提交一个task, 100会作为action()函数的参数
# future2 = pool.submit(action, 100)
# # 判断future1代表的任务是否结束
# print(future1.done())
# time.sleep(3)
# # 判断future2代表的任务是否结束
# print(future2.done())
# # 查看future1代表的任务返回的结果 阻塞
# print(future1.result())
# # 查看future2代表的任务返回的结果 阻塞
# print(future2.result())
# # 关闭线程池
# pool.shutdown()

# ancel()：取消该 Future 代表的线程任务。如果该任务正在执行，不可取消，则该方法返回 False；否则，程序会取消该任务，并返回 True。
# cancelled()：返回 Future 代表的线程任务是否被成功取消。
# running()：如果该 Future 代表的线程任务正在执行、不可被取消，该方法返回 True。
# done()：如果该 Funture 代表的线程任务被成功取消或执行完成，则该方法返回 True。
# result(timeout=None)：获取该 Future 代表的线程任务最后返回的结果。如果 Future 代表的线程任务还未完成，该方法将会阻塞当前线程，其中 timeout 参数指定最多阻塞多少秒。
# exception(timeout=None)：获取该 Future 代表的线程任务所引发的异常。如果该任务成功完成，没有异常，则该方法返回 None。
# add_done_callback(fn)：为该 Future 代表的线程任务注册一个“回调函数”，当该任务成功完成时，程序会自动触发该 fn 函数。
# 如果程序不希望直接调用 result() 方法阻塞线程，则可通过 Future 的 add_done_callback() 方法来添加回调函数，该回调函数形如 fn(future)。当线程任务完成后，程序会自动触发该回调函数，并将对应的 Future 对象作为参数传给该回调函数。

with ThreadPoolExecutor(max_workers=2) as pool:
    # 向线程池提交一个task 
    future_list = []
    for i in range(0, 2):
        tmp_future = pool.submit(action, (i + 1) * 50)
        future_list.append(tmp_future)
    def get_result(future):
        print(future.result())
    
    # 为future提供回调函数
    for future in future_list:
        future.add_done_callback(get_result)
    print('------done------')

7、threadingTimer

# python中使用threading.Timer作为定时函数
# 参考：https://www.pynote.net/archives/1783
# https://docs.python.org/3/library/threading.html#timer-objects
# 设置一个延迟时间，当经过了这么多时间后，某个函数被调用；如果希望反复调用，就需要编程在被调用的函数中，再次实现这个延迟一段时间调用函数的代码

# threading.Timer创建的是一个线程！这个细节要注意，定时器基本上都是在线程中执行。

# 如果定时器内的代码执行时间超过了定时器的间隔，怎么办？看来在python中，这个问题是不存在的，下一次定时器的计时开始，会在定时器代码执行完后才开始。
import time
import threading


def createTimer():
    t = threading.Timer(2, repeat)
    t.start()
    

def repeat():
    print('Now:', time.strftime('%H:%M:%S',time.localtime()))
    createTimer()
    
    
createTimer()