python多线程 wait python多线程处理for循环

文章目录

• 循环调用多线程
• 生产者消费者问题(threading.Condition())

循环调用多线程

希望实现下面效果
{‘data’: [{‘OuterThreadResult1’: {‘innerResult’: [‘in1’, ‘in2’]}}, {‘OuterThreadResult2’: {‘innerResult’: [‘in1’, ‘in2’]}}, {‘OuterThreadResult3’: {‘innerResult’: [‘in1’, ‘in2’]}}, {‘OuterThreadResult4’: {‘innerResult’: [‘in1’, ‘in2’]}}]}

• 内层多线程是向列表 innerResult = []添加元素，
• 内层多线程调用N次，并每次将内层返回的结果innerResult作为值，‘OuterThreadResulti’(i=1,…,N)作为键，并将键值对结果追加到OuterThreadResult = []中

最简单的方法自然是内层多线程写完后，外层直接循环调用内层多线程，但这种方法会拖慢程序运行速度，这里不做赘述。

第二种方法是外层多线程也考虑用多线程实现，起名外层多线程：

import threading


"""实现内层线程向列表里追加元素，外层线程调用内层线程，其中外层线程调用1次，内层线程会调用4次（4个内层线程）"""

def inner_thread_function(val):
    '''
    :param val:
    :return: 向内层线程列表中（innerResult：全局变量）添加值
    '''
    innerResult.append(val)


def inner_thread():
    """内层线程"""
    threads = []  # 存放线程
    l1=["in1","in2"]
    global innerResult
    innerResult = []

    for val in l1:
        # 创建子线程并存放至列表threads
        l = threading.Thread(target=inner_thread_function, args=(val,))
        threads.append(l)
    for t in threads:
        # 开启线程
        t.start()

    for t in threads:
        # 主线程等待子线程执行
        t.join()
    return {"innerResult": innerResult}


def outer_thread_function(val):
    '''
    在这里调用内层多线程
    :param val:
    :return:向外层线程列表（OuterThreadResult：全局变量列表）中调用内层线程，并添加内层线程返回值
    '''

    data = inner_thread()

    OuterThreadResult.append({"OuterThreadResult"+str(val): data})




import threading
def out_thread():
    '''外层多线程'''
    global OuterThreadResult
    OuterThreadResult = []

    threads = []  # 存放线程
    l2=["1","2","3","4"]

    for val in l2:
        # 创建子线程并存放至列表threads
        l = threading.Thread(target=outer_thread_function, args=(val,))
        threads.append(l)
    for t in threads:
        # 开启线程
        t.start()


    for t in threads:
        # 主线程等待子线程执行
        t.join()
    return {"data": OuterThreadResult}

OuterThreadResult = out_thread()
print(OuterThreadResult)

运行结果：

{‘data’: [{‘OuterThreadResult1’: {‘innerResult’: [‘in2’, ‘in1’]}}, {‘OuterThreadResult2’: {‘innerResult’: [‘in1’, ‘in2’]}}, {‘OuterThreadResult3’: {‘innerResult’: [‘in2’, ‘in1’, ‘in2’]}}, {‘OuterThreadResult4’: {‘innerResult’: [‘in2’, ‘in1’, ‘in2’]}}]}

从上述结果可以看出’OuterThreadResult3’，'OuterThreadResult4’结果不符合预期

结果分析：

• 当外部线程1 进入内部线程后，外部线程1的内部线程1会首先获取到全局变量innerResult = [],
  并添加了l1的元素"in1"，innerResult = [“in1”]，
• 此时外部线程2也进入内部线程，外部线程2 的内部线程1会首先获取到全局变量innerResult = []，并添加元素"in1"，innerResult = [“in1”]；
• 此时可能外部线程2 的内部线程2也抢到了线程操控权，它又向全局变量添加了l1的元素"in2"，innerResult = [“in1”，“in2”]；
• 然后外部线程1 的内部线程2会首先获取到全局变量innerResult = [“in1”，“in2”] – 这里已经不是我们希望的结果了，出现了全局变量修改混乱的问题,并添加了l1的元素"in2"，innerResult = [“in1”，“in2” ，“in2”]

这很明显是线程安全问题，（注意：如果是单层线程，一般要到达万的计算量级才会出现线程安全问题）。
既然是外层线程获取innerResult出现问题，考虑在外层线程加锁，这样每个外部线程都会有单独的innerResult=[]

import threading
lock = threading.Lock()

"""实现内层线程向列表里追加元素，外层线程调用内层线程，其中外层线程调用1次，内层线程会调用4次（4个内层线程）"""

def inner_thread_function(val):
    '''
    :param val:
    :return: 向内层线程列表中（innerResult：全局变量）添加值
    '''
    innerResult.append(val)


def inner_thread():
    """内层线程"""
    threads = []  # 存放线程
    l1=["in1","in2"]
    global innerResult
    innerResult = []

    for val in l1:
        # 创建子线程并存放至列表threads
        l = threading.Thread(target=inner_thread_function, args=(val,))
        threads.append(l)
    for t in threads:
        # 开启线程
        t.start()

    for t in threads:
        # 主线程等待子线程执行
        t.join()
    return {"innerResult": innerResult}


def outer_thread_function(val):
    '''
    在这里调用内层多线程
    :param val:
    :return:向外层线程列表（OuterThreadResult：全局变量列表）中调用内层线程，并添加内层线程返回值
    '''
    lock.acquire()
    data = inner_thread()

    OuterThreadResult.append({"OuterThreadResult"+str(val): data})
    lock.release()



import threading
def out_thread():
    '''外层多线程'''
    global OuterThreadResult
    OuterThreadResult = []

    threads = []  # 存放线程
    l2=["1","2","3","4"]

    for val in l2:
        # 创建子线程并存放至列表threads
        l = threading.Thread(target=outer_thread_function, args=(val,))
        threads.append(l)
    for t in threads:
        # 开启线程
        t.start()


    for t in threads:
        # 主线程等待子线程执行
        t.join()
    return {"data": OuterThreadResult}

OuterThreadResult = out_thread()
print(OuterThreadResult)

返回值：

{‘data’: [{‘OuterThreadResult1’: {‘innerResult’: [‘in1’, ‘in2’]}}, {‘OuterThreadResult2’: {‘innerResult’: [‘in1’, ‘in2’]}}, {‘OuterThreadResult3’: {‘innerResult’: [‘in1’, ‘in2’]}}, {‘OuterThreadResult4’: {‘innerResult’: [‘in1’, ‘in2’]}}]}

注意，经试验发现，嵌套的线程，若不在外层线程加锁，极易发生线程安全问题

但这么加锁本质和单线程没有区别呀，每次都要等一个外部线程执行完了，才可以执行下一个外部线程，这不就是循化吗（其实，一般情况下，我们对于锁的位置是需要谨慎考量的，一般要加在影响全局变量的语句位置，这个程序加在哪里都不合适）

考虑方法三
既然问题是全局变量innerResult会出现问题，那不妨每次个内部线程都给一个独立的全局变量，外部进程要执行四次，那我们创建4个全局变量不就可以了，

import threading


"""实现内层线程向列表里追加元素，外层线程调用内层线程，其中外层线程调用1次，内层线程会调用4次（4个内层线程）"""

def inner_thread_function(val,idx):
    '''
    :param val:
    :return: 向内层线程列表中（innerResult：全局变量）添加值
    '''
    globals()["innerResult_"+idx].append(val)


def inner_thread(idx):
    """内层线程"""
    threads = []  # 存放线程
    l1=["in1","in2"]
    globals()["innerResult_"+idx] = [] #

    for val in l1:
        # 创建子线程并存放至列表threads
        l = threading.Thread(target=inner_thread_function, args=(val,idx))
        threads.append(l)
    for t in threads:
        # 开启线程
        t.start()

    for t in threads:
        # 主线程等待子线程执行
        t.join()
    return {"innerResult": globals()["innerResult_"+idx]}


def outer_thread_function(val):
    '''
    在这里调用内层多线程
    :param val:
    :return:向外层线程列表（OuterThreadResult：全局变量列表）中调用内层线程，并添加内层线程返回值
    '''

    data = inner_thread(val)

    OuterThreadResult.append({"OuterThreadResult"+str(val): data})




import threading
def out_thread():
    '''外层多线程'''
    global OuterThreadResult
    OuterThreadResult = []

    threads = []  # 存放线程
    l2=["1","2","3","4"]

    for val in l2:
        # 创建子线程并存放至列表threads
        l = threading.Thread(target=outer_thread_function, args=(val,))
        threads.append(l)
    for t in threads:
        # 开启线程
        t.start()


    for t in threads:
        # 主线程等待子线程执行
        t.join()
    return {"data": OuterThreadResult}

OuterThreadResult = out_thread()
print(OuterThreadResult)

{‘data’: [{‘OuterThreadResult1’: {‘innerResult’: [‘in1’, ‘in2’]}}, {‘OuterThreadResult2’: {‘innerResult’: [‘in1’, ‘in2’]}}, {‘OuterThreadResult3’: {‘innerResult’: [‘in1’, ‘in2’]}}, {‘OuterThreadResult4’: {‘innerResult’: [‘in1’, ‘in2’]}}]}

生产者消费者问题(threading.Condition())

threading.Condition()进行有条件判断的锁

• 问题描述：“生产者生产1-3号商品，消费者消费1-3号商品，如商品总数<1，消费者不可以消费，商品总数>10,生产者不可以生产，2个生产者，1个消费者”

import threading
import time
import random

"生产者生产1-3号商品，消费者消费1-3号商品，如商品总数<1，消费者不可以消费，商品总数>10,生产者不可以生产，2个生产者，1个消费者"
cond = threading.Condition()


def customer_get_milk():
    while True:
        cond.acquire()
        if len(milk_list)<1:
            cond.wait() # 不满足条件，进入线程池等待

        else:
            print("消费者正在消费第s%号牛奶", milk_list[0])
            milk_list.remove(milk_list[0])
        cond.notify() # 执行完线程，唤醒线程池的其他线程
        cond.release() # 释放锁


def productor_yield_milk(num):
    while True:
        cond.acquire()
        if len(milk_list) > num:
           cond.wait()
        else:
            flag= 0
            for i in list(range(1,4)):
                if i not in milk_list:
                    milk_list.append(i)
                    flag =1
                    print("生产者正在生产第s%号牛奶", i)
            if not flag:
                temp = random.randint(1,3)
                milk_list.append(temp)
                print("生产者正在生产第s%号牛奶", temp)
        cond.notify()
        cond.release()


def thread_main():
    global milk_list
    milk_list = []
    t1 = threading.Thread(target=customer_get_milk, args=[])
    t2 = threading.Thread(target=productor_yield_milk, args=(10,))
    t3 = threading.Thread(target=productor_yield_milk, args=(10,))
    t1.start()
    t2.start()
    t3.start()
    t1.join()
    t2.join()
    t3.join()

if __name__ == '__main__':
    thread_main()

参考：【python】详解threading模块：Condition类的使用（三）