1 多线程技术
1.主线程
每个进程默认都会有一个线程，这个线程我们叫它主线程。
默认情况下，所有的代码都是在主线程中执行。2.子线程
一个进程中，可以有多个线程。除了主线程以外，其他的线程需要手动的添加。3.threading是python中的一个内置模块，用来支持多线程
a.Thread类
Thread类的对象就是线程对象，需要线程的时候，就创建这个类或者这个类的子类对象。
b.threading.current_thread() ---> 用来获取当前线程对象。
采用多线程的优势如下代码所示：
- 首先创建以一个模拟下载电影的类：
import threading
import datetime
import time
# 下载两个电影
def download(file):
# 打印当前线程
print(threading.current_thread())
print('开始下载：'+file, datetime.datetime.now())
# 让线程阻塞10秒
time.sleep(10)
print('开始结束：'+file, datetime.datetime.now())
- 分别在主线程中和子线程中去下载两个电影
# 1.在主线程中下载两个电影：总耗时20s
download('葫芦娃')
download('葫芦小金刚')
print('==================')
# 2.在两个子线程中去下载两个电影
"""
Thread(target, args)
target：需要在子线程中调用的函数的函数名
args：函数的实参
返回值：创建好的线程对象
"""
t1 = threading.Thread(target=download, args=('终结者',))
t2 = threading.Thread(target=download, args=('终结者2',))
# 开始执行t1对应的线程中的任务
t1.start()
# 开始执行t2对应的线程中的任务
# 想要在子线程中执行任务，必须通过线程对象调用start方法才行
t2.start()
print('=================')
输出结果：
<_MainThread(MainThread, started 31396)>
开始下载：葫芦娃 2018-09-13 16:46:35.315693
开始结束：葫芦娃 2018-09-13 16:46:45.316666
<_MainThread(MainThread, started 31396)>
开始下载：葫芦小金刚 2018-09-13 16:46:45.316666
开始结束：葫芦小金刚 2018-09-13 16:46:55.317155
==================
<Thread(Thread-1, started 31460)>
开始下载：终结者 2018-09-13 16:46:55.319155
<Thread(Thread-2, started 30736)>
开始下载：终结者2 2018-09-13 16:46:55.319155
=================
开始结束：终结者2 2018-09-13 16:47:05.320056
开始结束：终结者 2018-09-13 16:47:05.320056
可以看出在主线程中下载两个电影总耗时20s，但是在用两个子线程下载总耗时才10s。
2 面向对象的多线程技术
-
面向对象实现多线程技术
1.声明一个类继承自Thread类。
2.重写run方法，将需要在子线程中执行的任务放到run方法中。
3.在需要子线程的位置去创建这个类的对象，然后用对象调用start方法去执行run中的任务。
具体实现如下代码所示：
from threading import Thread
import datetime
import time
import random
# 注意：继承的时候，可以继承自己写的类，也可以继承系统的类或者别人写好的类
class DownloadThread(Thread):
"""下载线程类"""
def __init__(self, file):
super().__init__()
self.file = file
# 重写run方法
def run(self):
print(self.file + '开始下载：', datetime.datetime.now())
# 让线程阻塞10秒
time.sleep(random.randint(5,10))
print(self.file + '下载结束：', datetime.datetime.now())
通过创建线程对象，直接下载：
print('==============')
# 创建线程对象
t1 = DownloadThread('沉默的羔羊')
t1.start()
print('++++++++++++++')
输出结果为：
==============
沉默的羔羊开始下载： 2018-09-13 17:08:29.339085
++++++++++++++
沉默的羔羊下载结束： 2018-09-13 17:08:36.340270
3 join方法的使用
如果希望某个线程结束后才执行某个操作，就用那个线程调用join方法。
如下代码所示，其中DownloadThread同上：
t1 = DownloadThread('美丽人生')
t2 = DownloadThread('怦然心动')
t1.start()
t2.start()
# 系统t1和t2中的代码都结束后才执行下面的代码
t1.join() # 这句代码后面的代码在t1对应的线程结束后才执行
# t2.join()
end = time.time()
print(end)
输出结果为：
美丽人生开始下载： 2018-09-13 17:13:05.783241
怦然心动开始下载： 2018-09-13 17:13:05.783241
美丽人生下载结束： 2018-09-13 17:13:11.784258
1536829991.7842584
怦然心动下载结束： 2018-09-13 17:13:13.784979
可以看出线程1结束后，线程2才结束。
4 线程间的数据共享
当多个线程同时对一个数据进行操作的时候，可能会出现数据混乱的问题。这个时候需要用到Lock类。
具体操作如下代码所示，首先创建两个模拟存取钱的类，其中一个不加Lock锁，其他代码都一样：
- 不加锁的Account类：
class Account:
def __init__(self, balance):
# 余额
self.balance = balance
# 创建锁对象
self.lock = Lock()
# 存钱过程：读出原来的余额，确定钱的一系列操作，将原来的余额
def save_money(self, amount):
"""存钱"""
print('开始存钱！', datetime.datetime.now())
# 获取原理的余额
old_amount = self.balance
# 模拟时间消耗
time.sleep(5)
# 修改余额
self.balance = old_amount + amount
print('存钱成功！最新余额是：', self.balance, datetime.datetime.now())
def get_money(self, amount):
"""取钱"""
print('开始取钱！', datetime.datetime.now())
# 获取原理的余额
old_amount = self.balance
if old_amount < amount:
print('余额不足！')
return
# 模拟时间消耗
time.sleep(5)
# 修改余额
self.balance = old_amount - amount
print('取钱成功！最新余额是：', self.balance, datetime.datetime.now())
def show_balance(self):
print('当前余额为：', self.balance)
- 加锁的Account类
class Account:
def __init__(self, balance):
# 余额
self.balance = balance
# 创建锁对象
self.lock = Lock()
# 存钱过程：读出原来的余额，确定钱的一系列操作，将原来的余额
def save_money(self, amount):
"""存钱"""
print('开始存钱！', datetime.datetime.now())
# 加锁
self.lock.acquire()
# 获取原理的余额
old_amount = self.balance
# 模拟时间消耗
time.sleep(5)
# 修改余额
self.balance = old_amount + amount
print('存钱成功！最新余额是：', self.balance, datetime.datetime.now())
# 解锁
self.lock.release()
def get_money(self, amount):
"""取钱"""
print('开始取钱！', datetime.datetime.now())
# 加锁
self.lock.acquire()
# 获取原理的余额
old_amount = self.balance
if old_amount < amount:
print('余额不足！')
return
# 模拟时间消耗
time.sleep(5)
# 修改余额
self.balance = old_amount - amount
print('取钱成功！最新余额是：', self.balance, datetime.datetime.now())
# 解锁
self.lock.release()
def show_balance(self):
print('当前余额为：', self.balance)
创建子线程模拟存取钱：
account = Account(1000)
t1 = Thread(target=account.save_money, args=(200,))
t2 = Thread(target=account.save_money, args=(300,))
t3 = Thread(target=account.get_money, args=(800,))
t1.start()
t2.start()
t3.start()
- 不加锁的输出结果：
开始存钱！ 2018-09-13 17:35:07.086701
开始存钱！ 2018-09-13 17:35:07.086701
开始取钱！ 2018-09-13 17:35:07.086701
取钱成功！最新余额是： 200 2018-09-13 17:35:12.087528
存钱成功！最新余额是： 1300 2018-09-13 17:35:12.087528
存钱成功！最新余额是： 1200 2018-09-13 17:35:12.087528
- 加锁的输出结果：
开始存钱！ 2018-09-13 17:34:09.549730
开始存钱！ 2018-09-13 17:34:09.549730
开始取钱！ 2018-09-13 17:34:09.549730
存钱成功！最新余额是： 1200 2018-09-13 17:34:14.550900
存钱成功！最新余额是： 1500 2018-09-13 17:34:19.551785
取钱成功！最新余额是： 700 2018-09-13 17:34:24.552428
可以看出，不加锁的存取钱过程，余额是错误的，加锁的余额才是正常的。
