2018-09-13 day19 多线程

一.多线程技术

1.主线程：每个进程默认都会有一个线程，这个线程我们一般叫他主线程
默认情况下，所有的代码都是在主线程中执行
2.子线程
一个线程中可以有多个线程，除了主线程以外，其他的线程需要手动添加
3.threading是python中的内置模块，用来支持多线程
Thread类的对象就是线程对象，需要线程的时候，就创建这个类或者这个类的子类对象

import threading
import datetime
import time
def download(file):
    print("开始下载",datetime.datetime.now())
    time.sleep(5)
    print(file+"下载结束:",datetime.datetime.now())


# print("主线程中的代码")
# #1.在线程中下载两个电影
# download("速度与激情")
# download("沉默的羔羊")
print(threading.currentThread())

#2.在两个子线程中去下载电影
"""
Thread(target,args)
target:需要在子线程中调用的函数的函数名
args:函数的实参
返回值:创建好的线程对象

"""
t1 = threading.Thread(target=download,args=("速度与激情",))

#开始执行t1对应的线程中的任务
t1.start()

t2 = threading.Thread(target=download,args=("哆啦A梦",))
#想要在子线程中执行任务，必须通过线程对象调用start方法才行
t2.start()
print("==========")
输出:
<_MainThread(MainThread, started 5544)>
开始下载 2018-09-13 17:27:55.494570
开始下载 2018-09-13 17:27:55.495571
==========
速度与激情下载结束: 2018-09-13 17:28:00.494856
哆啦A梦下载结束: 2018-09-13 17:28:00.495857

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

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

from threading import Thread
import datetime
import time
from random import randint
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())
print("======")
t1 = DownloadThread("水形物语")
t1.start()
print("++++++")
输出:
水形物语开始下载: 2018-09-13 17:32:06.642935
++++++
水形物语下载结束: 2018-09-13 17:32:11.643221

3.join的方法的使用

from threading import Thread
import time
from datetime import datetime
from random import randint
#在两个子线程中下载两个电影，在主线程中统计两个电影下载的总的时间
#如果希望两个线程结束后才执行某个操作，就用那个线程调用join方法
class DownloadThread(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())
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)
输出:
钢铁侠开始下载: 2018-09-13 17:34:31.197203
金刚狼开始下载: 2018-09-13 17:34:31.197203
钢铁侠下载结束: 2018-09-13 17:34:38.197604
金刚狼下载结束: 2018-09-13 17:34:43.197890
12.001686573028564

4.线程间的数据共享

模拟多个人对同一个账号进行操作
同步锁（RLock）和互斥锁（Lock）

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


    #存钱的过程：读出原来的余额，确定钱的一系列操作，
    # 将原来的余额加上存的数额，产生最新的余额再保存
    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):
        print("开始取钱")
        self.lock.acquire()
        old_amount = self.balance
        if old_amount < amount:
            print("余额不足！")
            return
        time.sleep(5)
        self.balance = old_amount - amount
        print("取钱成功，余额：",self.balance)
        self.lock.release()
    def show_balance(self):
        print("当前余额为：",self.balance)

#创建账号
account = Account(1000)
# account.save_money(200)
# account.get_money(100)
"""
当多个线程同时对一个数据进行操作的时候，可能会出现数据混乱的问题
"""

t1 = Thread(target=account.save_money,args=(200,))
t2 = Thread(target=account.save_money,args=(1300,))
t3 = Thread(target=account.get_money,args=(800,))
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
account.show_balance()
输出:
当前余额为： 1000
开始存钱
开始存钱
开始取钱
存钱成功,余额： 1200
存钱成功,余额： 2500
取钱成功，余额： 1700
当前余额为： 1700