2018-09-13 day19-多线程

多线程技术

• 主线程 每个进程都会有一个线程, 这个线程是主线程。默认情况下, 所有代码都是在主线程中执行。
• 子线程 一个进程可以有多个线程,除了主线程的其他子线程需要去创建
• 创建线程通过导入threading模块。 threading是python中创建线程的内置模块，用来支持多线程。Thread类的对象就是线程，需要线程时，可创建这个类或其子类的对象。
• 实例

import threading
from datetime import datetime
import time
# 模拟下载电影
def download(file):
    print(threading.currentThread())
    print(file+' 开始下载',datetime.now())
    time.sleep(10)
    print(file+' 结束下载', datetime.now())
# 在两个子线程中去下载电影
'''
Thread(target,args)
target:需要在在线程中调用的函数的函数名
args: 函数的实参
返回值:创建好的线程对象
'''

if __name__ == '__main__':

    print(threading.current_thread())
    print('主线程位置')
    print('===============================')
    t1 = threading.Thread(target=download, args=('闻香识女人',))
    #
    t1.start()#想要子线程执行任务，通过线程对象调用start方法
    print('=============================')
    t2 = threading.Thread(target=download, args=('猫鼠游戏',))
    #
    t2.start()  # 执行线程的代码

result:
<_MainThread(MainThread, started 10552)>
主线程位置
===============================

闻香识女人 开始下载 2018-09-15 09:27:07.418839
=============================

猫鼠游戏 开始下载 2018-09-15 09:27:07.418839
猫鼠游戏 结束下载 2018-09-15 09:27:17.419411
闻香识女人 结束下载 2018-09-15 09:27:17.419411

---

面向对象的多线程

• 步骤
  1.声明一个类，继承Thread类
  2.重写run()方法,将需要在子线程中执行的任务，放到run()方法中
  3.在需要线程的位置，去创建这个类的对象然后用对象调用start方法，去执行run中的任务。
• 案例

rom threading import Thread
from datetime import datetime # 从datetime包中引入datetime模块
import time
class R_Thread(Thread):
    """下载线程类"""
    def __init__(self,name):
        super().__init__()
        self.name = name
    def run(self):
        print(self.name+' 开始下载',datetime.now())
        time.sleep(5)
        print(self.name+' 下载结束',datetime.now())
if __name__ == '__main__':
    print('=========================')
    t1 = R_Thread('闻香识女人')
    t1.start()
    print('============================')

---

join方法

如果希望某个线程结束后才执行后续的操作，调用join方法

• 案例

from threading import  Thread
from datetime import datetime
import time
from random import randint
# 在两个子线程中下载两个电影,在主线程中国统计两个电影下载的总时间
class R_Thread(Thread):
    def __init__(self,file):
        super().__init__()
        self.file = file
    def run(self):
        print(self.file+' 开始下载',datetime.now())
        time.sleep(randint(5,15))
        print(self.file+' 下载结束',datetime.now())
if __name__ == '__main__':
    t1 = R_Thread('闻香识女人')
    start = time.time()
    print(start)
    t1.start()
    t2 = R_Thread('美丽人生')
    t2.start()
    '''
    如果希望某个线程结束后才执行后续的操作，调用join方法
    '''
    t1.join() #这句代码后面的代码需要在t1对应的线程结束后执行
    t2.join()
    end = time.time()
    print(end)
    print(end-start)

---

多个线程数据共享

通过加锁的方式，以解决多个线程同时对一个数据进行操作二带来的数据紊乱的问题。

import time
from datetime import datetime
from threading import Thread,Lock,RLock
class Account:
    """账号类"""
    def __init__(self,balance):
        self.balance = balance
        # 创建锁对象
        self.lock = Lock()
    # 存钱: 读余额, 确定钱的数目
    def save_money(self,amount):
        self.lock.acquire()
        # 获取原来的余额
        old_amount = self.balance
        # 模拟时间消耗
        time.sleep(5)
        # 修改余额
        self.balance = old_amount + amount
        print('存钱成功,余额',self.balance)
        self.lock.release()
    # 取钱
    def get_money(self,amount):
        self.lock.acquire()
        old_amount = self.balance
        if old_amount < amount:
            print('余额不足')
            return
        time.sleep(10)
        self.balance = old_amount - amount
        print('取钱成功,余额',self.balance)
        self.lock.release()
    def show_balance(self):
        print('余额:',self.balance)



if __name__ == '__main__':
    account = Account(1000)
    account.show_balance()
    '''
    当多个线程同时对一个数据进行操作的时候,可能出现数据紊乱的问题
    '''
    t1 = Thread(target=account.save_money,args=(200,))
    t2 = Thread(target=account.get_money,args=(400,))
    t1.start()
    t2.start()

    t1.join()
    account.show_balance()
    t2.join()
    account.show_balance()