多线程简解

多任务操作机制的引入：在相同的硬件资源下提高任务的处理效率
在提升任务处理效率的基础上，提升用户体验
Python本身多任务处理机制
多线程任务处理机制（小民营企业式）
多进程任务处理机制（大型国企式）
协程多任务处理机制（家庭作坊式）

进程：计算机中一个程序在一个数据集上一次动态执行的过程
程序：描述进程的功能以及处理流程
数据集：功能处理过程中需要的资源数据
进程控制：严格控制进程执行过程中的各种状态（堵塞...等）

一个软件程序要运行，需要将软件依赖的数据加载到内存之中，通过CPU进行运算，并按照程序定义的逻辑进行流程控制，直到数据处理完成之后程序退出
在程序执行的过程中，进程只是负责分配需要的资源数据，是程序的主体
程序运行过程中真正运行的是线程
每个进程中至少有一个线程（主线程）

进程主要是用来分配任务，真正干活的是线程

线程：计算机中程序运行的实际执行者，又称轻量级线程，是一个CPU的执行单元。
每个进程中至少有一个线程（主线程）
一个线程只能属于一个进程
一个进程可以有多个线程，多个线程之间可以共享进程中提供的数据
CPU运算分配给线程，CPU 上运算执行的就是线程
线程是最小的运行单元， 进程是最小的资源管理单元

形象化：
进程：公司老板，提供资源给线程使用
主线程：管理人员/干活
子线程：干活的人

串行：传统意义上的同步，顺序的意思，按照一定的执行步骤顺序执行每个环节
并行：传统意义上的异步，同时的意思，多个任务同时执行，同时执行接收到的多个任务
并发：同时接收到多个任务，同时执行多个任务，但是具体到某个时刻的时候只在执行其中 一个任务，只不过是在很短的时间内在多个任务之间切换，模拟形成了多个任务在同 时执行的现象

Python中支持并行操作，但为了保证多任务机制下的共享数据的安全，python内置了一个GIL（全局解释器）只允许同一时间内CPU只能执行一个线程。所以在python的官方解释器下，多线程是多线程并发机制

Python中多线程并发机制
提供了两种模块：_thread 和 threading
_thread 适合用于大神
threading 适合新手使用（官方推荐）

_thread 的使用：

#引入需要的模块
import _thread, time


#定义第一个函数
def sing():
    for i in range(20):
        print("篝火盛宴！！！")


#定义第二个函数
def info():
    for i in range(20):
        print("载歌载舞！！！")


#创建多个线程
_thread.start_new_thread(sing, ())
_thread.start_new_thread(info, ())

#让系统主线程等待子线程运行结束
time.sleep(3)

threading 的使用：
可以实现面向过程的并发编程
也可以实现面向对象的并发编程

常用的threading 模块属性和方法
Thread 线程类，用于创建和管理线程
Event 事件类，用于作线程同步 添加一个标志，通过标志进行等待，运 行，清除
Condition 条件类，用于作线程同步 可以实现加锁，开锁，等待，运行等
Lock/RLock 锁类，用于线程同步 加锁/开锁
Timer 延时线程，用于在一定事件后在执行一个异步函数

常见的Thread 模块属性和方法
init(name线程名称，target面向过程开发时指定执行的函数，args面向过程开发时指定给函数的参数) 构建方法，构建线程类型
run() 面向过程开发时，需要重写的方法，线程一旦启动，会自动执行
start() 线程启动的方法，会创建一个新的线程，并自动调用run方法
join 独占模式
deamon 守护线程

基于threading模块的多线程并发编程（火车票售票窗口）

#引入需要的模块
import threading, time

#定义车票
che_piao = 10

#定义线程锁对象
lock = threading.Lock()

#定义售票函数
def shou_piao():

    global che_piao

    while True:
        time.sleep(0.5)

        #线程锁上锁
        if lock.acquire():
            if che_piao > 0:
                che_piao -= 1
                print("售出一张车票")

            else:
                print("本车次票已售完")
                # 线程锁解锁
                lock.release()
                break
            lock.release()

if __name__ == "__main__":
    # #单线程售票系统
    # shou_piao()

    #多线程售票系统
    for i in range(5):
        t = threading.Thread(name = "窗口"+str(i), target=shou_piao)
        t.start()

# #定义一个售票窗口
# t1 = threading.Thread(name='一号售票窗口', target=shou_piao)
#
# #启动代码
# t1.start()

线程管理——锁（Lock/RLock)
多线程程序在运行过程中，由于多个线程访问的时同一部分数据，很容易会造成共享数据访问冲突的现象，如果一旦出现冲突程序就会出现与执行结果不符合期望的结果
python 提供了两种线程锁的操作
同步锁/互斥锁： Lock
可重用锁： RLock
锁的操作
acquire(), 获取锁，上锁
Release(), 释放锁，解锁

#引入需要的模块
import threading, time

#定义车票
che_piao = 10

#定义线程锁对象
lock = threading.Lock()

#定义售票函数
def shou_piao():

    global che_piao

    while True:
        time.sleep(0.5)

        #线程锁上锁
        if lock.acquire():
            if che_piao > 0:
                che_piao -= 1
                print("售出一张车票")

            else:
                print("本车次票已售完")
                # 线程锁解锁
                lock.release()
                break
            lock.release()

if __name__ == "__main__":
    # #单线程售票系统
    # shou_piao()

    #多线程售票系统
    for i in range(5):
        t = threading.Thread(name = "窗口"+str(i), target=shou_piao)
        t.start()

# #定义一个售票窗口
# t1 = threading.Thread(name='一号售票窗口', target=shou_piao)
#
# #启动代码
# t1.start()

线程管理——死锁（哲学家吃饭问题）
线程锁固然功能强大，可以管理多个线程之间的共享数据问题 但是同时它的强大也带来了比较纠结的问题，需要开发人员对于锁定的数据有一个良好的认知，否则特别容易造成死锁的现象，比较著名的哲学家吃饭问题就是死锁的典型代表

由于计算机运算速度较快，所以有两种方案可以将问题放大
给执行函数添加休眠时间
添加线程数量
死锁并不是每次都会出现的，而是程序在执行过程中，根据系统 CPU 时间片的切换机制恰 好遇到了重复上锁的情况，就会死锁
死锁情况可以用重用锁 RLock 进行锁定处理

#引入需要的模块
import threading

#定义两把锁
lock_a = threading.Lock()
lock_b = threading.Lock()


def ZhexueA():
    for i in range(200):
        if lock_a.acquire():
            if lock_b.acquire():
                print("你给我刀子，我给你叉子")
                lock_b.release()
            lock_a.release()

def ZhexueB():
    for j in range(200):
        if lock_b.acquire():
            if  lock_a.acquire():
                print("你给我叉子， 我给你刀子")
                lock_a.release()
            lock_b.release()

if __name__ == "__main__":

    bj = threading.Thread(target=ZhexueA)
    bj.start()
    ss = threading.Thread(target=ZhexueB)
    ss.start()

线程管理——事件
针对多个线程之间的通信的问题，python提供了Event进行处理
Event.set() 添加一个标记状态
Event.clear() 清除标记状态
Event.wait() 事件对象操作的当前线程等待，直到该对象被标记状态

Event实现

"""
小贩：生产油条
顾客：消费油条
需求：顾客消费

两个线程之间的通信：事件对象， threading.Event
event.set()  添加标记
event.wait()  线程等待
event.clear()
"""

#引入需要的模块
import threading,time

#定义一个事件对象
event = threading.Event()

#定义商贩
def shang_fan():
    print("商贩：铁锅油条")
    time.sleep(2)
    #添加标记
    event.set()
    #清除标记
    event.clear()

    print("商贩：刚出锅的")
    #线程等待
    event.wait()

    print("商贩：谢谢光临")


#定义顾客
def gu_ke():
    #线程等待
    event.wait()
    print("顾客：老板，两根油条")

    time.sleep(2)
    print("顾客：外焦里嫩")

    print("顾客：下次还来")
    #添加标记
    event.set()

if __name__ == "__main__":
    sf = threading.Thread(target=shang_fan)
    gk = threading.Thread(target=gu_ke)

    sf.start()
    gk.start()

线程管理——条件
线程条件 Condition 对象，也是多线程并发模式下一种线程之间的通信
Condition.acquire() 锁定
Condition.release() 解锁
Condition.wait() 释放锁
Condition.notify() 唤醒

Condition 的实现

#引入需要的对象
import threading, time, random

#创建一个条件对象
con = threading.Condition()

#创建篮子
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(1,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()

线程管理——队列
多线程并发编程的重点，是线程之间共享数据的访问问题和线程之间的通信问题 为了解决线程之间数据共享问题，PYTHON 提供了一个数据类型【队列】可以用于在多线程 并发模式下，安全的访问数据而不会造成数据共享冲突
put([timeout=None]) 向队列中添加数据，队列如果满了，一直阻塞直到超时或者队 列中有数据被删除之后添加成功
get([timeout=None]) 从队列中获取数据，如果队列为空，一直阻塞直到超时或者队 列中添加数据之后获取成功
队列实现Queue：

#引入需要的模块
import threading, queue, time, random

# #创建一个条件对象
# con = threading.Condition()

#定义一个队列储存数据
basket = queue.Queue(20)

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(0.5)
        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()