多线程

什么是多线程
理解：默认情况下，一个程序是由一个进程和一个线程，代码是依次执行的，而多线程则可以并发执行，一次性多个人多个事，自然比单线程更快。

用Python内置模块写一个多线程的程序

threading模块是Python中专门提供多线程编程的模块。threading模块中最常用的类是Thread。
单线程代码

# @Time : 2019/11/18 15:26 
# @Author : 大数据小J
def coding():
    for x in range(3):
        print('%s正在写代码'%x)
        time.sleep(1)
        
def drawing():
    for x in range(3):
        print('%s正在画图'%x)
        time.sleep(1)
        
def sing_thread():
    coding()
    drawing()
    
if __name__ == '__main__':
    sing_thread()

设置了代码运行停留时间，单线程代码一共花费了六秒

继承来自threading.Tread类
1、使用thread.curret_thread()可以看到当前主线程的信息
2、使用thread.enumerate()可以看到当前的线程
为了让线程代码更好的封装。可以使用threading模块中的Tread类，继承自这个类，然后实现类中的定义的类方法来实现，线程会自动运行类中的类方法
多线程代码如下：

# @Time : 2019/11/18 15:26 
# @Author : 大数据小J
# @File : Python_多线程练习.py

import threading
import time
#创建一个类继承该多线程
class Write_data(threading.Thread):

    def run(self):
        the_thread = threading.current_thread() # threading.current_thread()这个方法获取主线程
        for i in range(3):
            print('%s正在写代码'%threading.enumerate())   #获取线程的名字
            time.sleep(1)


#创建第二个类继承该多线程
class Dicture_data(threading.Thread):

    def run(self):
        the_thead = threading.current_thread()
        for i in range(3):
            print('%s正在执行其他结果'%threading.enumerate())
            time.sleep(1)


#创建一个函数去进行两个类的调用
def main():
    t1 =  Write_data()
    t2 = Dicture_data()
    t1.start()
    t2.start()



dif __name__ == '__main__':
    main()

设置代码停留时间，多线程代码一共花费了3秒

多线程共享全局变量的问题
多线程都是在同一个进程中运行的。因测在进程中的全局变量所有的线程都是可共享的。这就造成了一个问题，因为线程执行的顺序是无序的。有可能会造成数据错误。

当不使用锁的时候，多线程共享中会造成数据错误

import  threading

ticket = 0

def get_ticket():
    global ticket
    for x in range(10000000):
        ticket += 1
    print('ticket:%d'%ticket)

def main():
    for x in range(2):
        t = threading.Thread(target=get_ticket)
        t.start()

if __name__ == '__main__':
    main()

#运行结果：
# ticket:10814578
# ticket:11338345

锁机制和threading.LOCK类
为了解决共享全局变量的问题。threading提供了一个Lock类，这个可以在某个线程中访问某个类的时候加锁，其他线程此时就不能进来，直到当前线程处理完后，把锁释放了，其他线程才能进来处理代码如下：

import  threading

ticket = 0
glock = threading.Lock()

def get_ticket():
    global ticket
    glock.acquire()   #进行加锁
    for x in range(10000000):
        ticket += 1
    glock.release()   #释放锁
    print('ticket:%d'%ticket)

def main():
    for x in range(2):
        t = threading.Thread(target=get_ticket)
        t.start()

if __name__ == '__main__':
    main()

#运行结果：
# ticket:10000000
# ticket:20000000

使用锁的原则：
1、把尽量少的代码和不耗时的代码放在锁中执行
2、代码执行完后记得释放锁
在Python中threading.Lock是创建锁,lock.acquire()是上锁操作，lock.release()是释放锁操作
生产者和消费者模式
生产者和消费者模式是多线程开发中经常见到的一种模式。生产者的线程专门用来生产一些数据，然后存放到一个中间变量中。消费者再从这个中间的变量取出数据进行消费。通过生产者和消费者模式可以让代码高内聚低耦合的目标，程序的分工更加明确，线程更加的方便管理

Lock版的生产者和消费者模式
生产者和消费者因为中间要使用变量，中间变量经常是一些全局变量，因此需要使用锁来保证数据完整性。以下使用threading.Lock锁实现”生产者和消费者模式“的一个例子

# @Time : 2019/11/19 20:17 
# @Author : 大数据小J
# @File : Python_多线程lock版.py

import threading
import random
import time

gMoney = 0
# 在全局变量中创建一个锁
gLock = threading.Lock()
# 次数
gTimes = 0


# 创建一个生产者
class Producer(threading.Thread):
    def run(self) -> None:
        # 创建生产者模式
        global gMoney
        global gTimes
        while True:
            # 创建一个变量定义随机获取生产的钱数,并进行上锁和释放锁
            gLock.acquire()  # 上锁
            if gTimes >= 10:
                gLock.release()
                break
            money = random.randint(0, 100)
            gMoney += money
            gTimes += 1
            print('%s生产者消费了%d' % (threading.current_thread().name, money))
            gLock.release()  # 释放锁
            time.sleep(1)


# 创建一个消费者
class Consumer(threading.Thread):
    def run(self) -> None:
        # 创建消费者模式
        global gMoney
        global gTimes
        while True:
            # 创建一个变量定义随机消费的钱数，并进行上锁和释放锁
            gLock.acquire()
            money = random.randint(0, 100)
            if gMoney >= money:
                gMoney -= money
                print('%s消费者消费了%d' % (threading.current_thread().name, money))
            else:
                if gTimes >= 10:
                    gLock.release()
                    break
                print('%s消费了%d,但是余额只有%d' % (threading.current_thread().name, money, gMoney))
            gLock.release()
            time.sleep(1)


# 启动多线程模式
def main():
    for i in range(5):
        th = Producer(name='生产者%s' % (i))
        th.start()

    for i in range(5):
        th = Consumer(name='消费者%s' % (i))
        th.start()


if __name__ == '__main__':
    main()

Condition版的生产者和消费者模式
Lock版本的生产者和消费者模式可以正常运行。但是存在一个不足，在消费者中通过while True死循环并且上锁的方式去判断钱够不够。上锁是一个很耗负CPU资源的行为。因此这种方式不是最好的，还有一种更好的方式便是使用thread.Condition来实现。thread.Condition可以在没有数据的时候处于阻塞等待状态。一旦有合适的数据了，还使用notify相关的函数来通过其他处于等待的状态的线程。这样就可以做一些无用的上锁和解锁的操作。可以提高程序的性能。首先对threading.Condition相关的函数做个介绍，threading.Condition类似于thrading.Lock,可以在修改全局数据的时候进行上锁，也可以在修改全局完毕后进行解锁。以下将一些常用的函数做简单的介绍：
1、acquire:上锁。
2、release:解锁
3、wait:将当前线程处于等待状态，并且会释放锁。可以被其他线程使用notity和notity_all函数唤醒，被唤醒会继续等待上锁，上锁后会继续执行下面的代码。
4、notify:通知某个正在等待的线程，默认是第1个等待的线程
5、notify_all:通知所有正在等待的线程。notify和notify_all不会释放锁，并且需在release之前调用

# @Time : 2019/11/19 23:20 
# @Author : 大数据小J
# @File : Python——多线程Condition练习.py

#导入多线程模块
import threading
import random
import  time

#生产的钱数
gMoney = 0
#
gTime = 0

#在全局中创建一个锁
gCondition = threading.Condition()

#创建一个生产者
class Producer(threading.Thread): #继承
    def run(self) -> None:
        #声明全部变量
        global gMoney
        global  gTime
        #上锁操作
        while True:
            gCondition.acquire()
            if gTime >=10:
                #释放掉锁
                gCondition.release()
                break
        #随机生成钱数
            money = random.randint(0,100)
            gMoney += money
            gTime += 1
            print('%s生产者消费了%d' % (threading.current_thread().name, money))
            #通知所有正在等待线程的锁
            gCondition.notify_all()
            #并进行上锁操作
            gCondition.release()
            time.sleep(1)

#创建一个消费者模式
class  Consume(threading.Thread):
    def run(self) -> None:
        #声明全局变量
        global gMoney
        global gTime
        while True:
            gCondition.acquire()
            money = random.randint(0,100)
            while gMoney < money:
                if gTime >= 10:
                    print('%s消费者消费了%d' % (threading.current_thread().name, money))
                    gCondition.release()
                    return
                #线程将继续等待
                print('%s消费了%d元钱，但是余额不足%d元钱，消费失败'%(threading.current_thread().name,money,gMoney))
                gCondition.wait()
            gMoney -= money
            print('%s消费了%d元钱，剩余%d元钱' % (threading.current_thread().name, money, gMoney))
            gCondition.release()
            time.sleep(1)


# 启动多线程模式
def main():
    for i in range(5):
        th = Producer(name='生产者%s' % (i))
        th.start()

    for i in range(5):
        th = Consume(name='消费者%s' % (i))
        th.start()


if __name__ == '__main__':
    main()