Python之多线程开发

以前我们接触的都是单线程单进程的python编程方式，从今天开始我们开始接触多线程和多进程的开发模式。首先多线程就是在一个程序中可能会有多条线程执行，但是Windows系统提供的是并发机制，Linux提供的是并行机制，所谓并发机制就是一个程序中多条线程并不是同时执行，而是根据时间片来决定在某一时刻执行哪一个线程，因为计算机运行的速度非常快，所以我们根本看不出来到底是哪条线程在执行，或则说我们会以为并发机制是和并行机制是一样的，都是在同时运行。所以多线程并发就可以认为是线程在同一时间执行的。因为时间片是由CPU决定的，所以我们不能预知在某一时刻执行哪条线程。在某个程序中有一个主线程，然后由主线程派生出多个子线程。多线程有两种实现方式，一是面向过程式的多线程并发，一种是面向对象式的类型式的并发。
多线程的模块有两个，一是_thread模块，二是threading模块。但是我们推荐使用的是threading模块，因为threading模块是根据前者改良后的，使用更加灵活。具体的代码实现如下：
A = threading.Thread(name=”**”,target=”函数名”) #这是面向函数编程
面向对象式的多线程编程是先定义一个类，然后继承threading.Thread类，重写父类方法，然后重写run方法具体代码如下：

import threading
class A(threading.Thread):
    def __init__(self,name):
        super().__init__(name=name)
    def run(self):
        print("现在执行的是run方法")
if __name__ == "__main__":
    for i in range(3):
        a = A("tom")
        a.start()  

然后接下来是几个案例分析：
1.哲学家吃饭问题，每个哲学家有两个刀子或叉子，除非一个哲学家释放自己的资源，然后给另一个哲学家，同时零一个哲学家释放自己的资源给这个哲学家，然后两个哲学家才能吃饭。具体代码就不写了，可以说一下流程：
创建两把资源锁，然后在给对方传数据时对方要先将自己的数据加上锁，然后自己传输的数据也要加锁，然后创建两个线程就可以了。但是这种程序存在弊端，很容易造成死锁，死锁就是双方互相占有者资源然后都不释放，最后导致程序死锁。
2：卖油条问题，通信事件对象问题
event = threading.Event()，创建一个事件，通过event.set()是标记一个事件，通过标记这个事件然后让另一个正在event.wait()的线程可以开始执行
2.多生产者多消费者问题，案例：卖包子，条件对象问题
con = threading.Condition()
basket = list()
通过列表的长度来判断篮子里是否还有包子，以此来判断生产者是否需要继续做包子，而消费者则根据长度来判断是否继续可以吃包子
生产者、消费者问题
公共的数据[篮子]
生产者：蒸包子-> 放到篮子中：并且告诉[唤醒]所有消费者可以吃了
如果篮子满了，所有 生产者 等待
消费者：吃包子-> 从篮子中获取数据，并且告诉[唤醒]所有生产者继续蒸包子
如果篮子空了，所有 消费者 等待

import threading, time, random
·
# 创建一个条件对象
con = threading.Condition()
'''
acquire() 上锁
release() 解锁
wait() 等待
wait_for() 等待
notify() 唤醒
notify_all() 唤醒所有
'''
# 篮子
basket = list()

def product():
    while True:
        time.sleep(1)
        # 上锁
        con.acquire()

        if len(basket) > 20:
            print(threading.current_thread().getName(), " : 篮子满了，可以吃包子了")
            con.wait()
        else:
            # 生产一个包子
            _no = random.randint(0, 10)
            print(threading.current_thread().getName(), " : 蒸包子--", _no)
            basket.append(_no)
            con.notify()
        # 解锁
        con.release()
def consumer():
    while True:
        time.sleep(0.5)
        # 上锁
        con.acquire()
        if len(basket) <= 0:
            print(threading.current_thread().getName(), "： 篮子空了， 生产者赶紧生产")
            con.wait()
        else:
            _no = basket.pop()
            print(threading.current_thread().getName(), "-消费了-", _no)
            con.notify()
        # 解锁
        con.release()
if __name__ == "__main__":
    # 生产者
    for i in range(5):
        p = threading.Thread(name="生产者" + str(i) + "号", target=product)
        p.start()
    # 消费者
    for j in range(5):
        c = threading.Thread(name="消费者" + str(j) + "号", target=consumer)
        c.start()

# 生产者消费者
import threading, queue, time, random
# 创建一个队列，存储数据
basket = queue.Queue(10)
'''
put(data [, timeout=None])
    向队列中添加数据，如果队列已满~一直等待[到超时]
get([timeout=None])
   从队列中获取数据，如果队列已空~一直等待[到超时]
特性：线程安全！
'''
def product():
    while True:
        time.sleep(1)
        _no = random.randint(0, 10)
        try:
            basket.put(_no, timeout=1)
            print("生产者生产了一个数据", _no)
        except:
            print("篮子已满.....")
def consumer():
    while True:
        time.sleep(1)
        try:
            _no = basket.get(timeout=1)
            print("消费者获取了一个数据", _no)
        except:
            print("篮子已空.....")


if __name__ == "__main__":
    for i in range(2):
        p = threading.Thread(target=product)
        p.start()

    for j in range(1):
        c = threading.Thread(target=consumer)
        c.start()