一.多线程技术

1.主线程

每个进程默认都会有一个线程,这个线程我们一般叫主线程
默认情况下,所有的代码都是在主线程中执行

2.子线程

一个进程中可以有多个线程,除了主线程以外,其他的线程需要手动添加

3.threading是python中的一个内置模块,用来支持多线程

a.Thread类的对象就是线程对象,需要线程的时候,就创建这个类或者这个类的子类对象
b.threading.currentThread() --> 用来获取当前线程对象

import threading
import datetime
import time
# 下载两个电影
def download(file):
    print('开始下载:'+file, datetime.datetime.now())
    # 让线程阻塞10秒
    time.sleep(10)
    print(file+'下载结束', datetime.datetime.now())



if __name__ == '__main__':
    print('主线程中的代码')
    print(threading.currentThread())

    # 1.在主线程中下载两个电影:总共耗时20秒
    # download('终结者2')
    # download('沉默的羔羊')

    # 2.在子线程中去下载两个电影
    """
    Thread(target,args)
    target:需要在子线程中调用的函数的函数名
    args:函数的实参
    返回值:创建好的线程对象
    """
    t1 = threading.Thread(target=download, args=('终结者',))
    # 开始执行t1对应的线程中的人物
    t1.start()
    t2 = threading.Thread(target=download, args=('沉默的羔羊',))
    # 想要在子线程中执行任务,必须通过线程对象调用start方法才行
    t2.start()
    print('==============')

二.面向对象的多线程技术

1.声明一个类继承自Thread类
2.将需要在子线程中执行的任务放到run方法中
3.在需要子线程的位置去创建这个类的对象,然后用对象调用start方法去执行run中的任务

注意:继承的时候可以继承自己写的类,也可以继承系统的类

class DownloadThread(Thread):
    """下载线程类"""
    def __init__(self, file):
        super().__init__()
        self.file = file

    def run(self):
        print(self.file + '开始下载:', datetime.datetime.now())
        time.sleep(randint(5, 10))
        print(self.file + '下载结束:', datetime.datetime.now())
if __name__ == '__main__':
    print('===============')
    t1 = DownloadThread('沉默的羔羊')
    t1.start()
    print('+++++++++++++++')

三.join方法的使用

在两个子线程中下载两个电影,在主线程中去统计两个电影下载的总时间
如果希望某个线程结束后才执行某个操作,就用那个线程调用join方法

class DownloadThread(Thread):
    """下载线程类"""
    def __init__(self, file):
        super().__init__()
        self.file = file

    def run(self):
        print(self.file + '开始下载:', datetime.datetime.now())
        time.sleep(randint(5, 15))
        print(self.file + '结束下载:', datetime.datetime.now())
        return 10

if __name__ == '__main__':

    t1 = DownloadThread('美丽人生')
    t2 = DownloadThread('怦然心动')

    start = time.time()

    tim1 = t1.start()
    tim2 = t2.start()

    # 系统t1和t2中的代码都结束后才执行下面的代码
    t1.join()   # 这句代码后面的代码在t1对应的线程结束后才执行
    t2.join()
    end = time.time()
    print(end-start)

四.线程间的数据共享

模拟多个人对同一个账号进行操作
同步锁(Rlock)和互斥锁(Lock)

class Account:
    """账号类"""
    def __init__(self, balance):
        # 余额
        self.balance = balance
        # 创建锁对象
        self.lock = Lock()
        self.lock = RLock()

    def save_money(self, amount):
        """存钱"""
        print('开始存钱')
        # 加锁
        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):
        """取钱"""
        old_amount = self.balance
        if old_amount < amount:
            print('余额不足')
            return
        time.sleep(5)
        self.balance = old_amount - amount

    def show_balance(self):
        print('当前余额:', self.balance)

if __name__ == '__main__':
    # 创建账号
    a1 = Account(1000)

    # a1.save_money(200)
    # a1.save_money(300)
    # a1.show_balance()

    """
    同一个线程
    """
    t1 = Thread(target=a1.save_money,args=(200,))
    t2 = Thread(target=a1.save_money,args=(300,))

    t1.start()
    t2.start()
    a1.show_balance()