01-多线程技术
1.主线程
每个进程默认都会有一个线程，这个线程我们一般叫作主线程
默认情况下，我们所有的代码都在主线程中执行的
2.子线程
一个进程可以有多个线程，除了主线程以外，其它的线程需要手动添加
3.threading是Python中的一个内置模块，用来支持多线程
a.Thread类
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__':
# threading.Thread
print('主线程中的代码')
print(threading.currentThread())
# 1.在主线程中下载两个电影：用时20s
# download('西虹市首富')
download('沉默的羔羊')
# 2.在子线程中下载两个电影:用时10s
'''
Tread(target,args)
target:需要在子线程中调用的函数的函数名
args:函数的实参
返回值：创建好的线程对象
'''
t1 = threading.Thread(target= download,args=('西虹市首富',))
# 开始执行t1对应的线程任务
t1.start()
# t2 = threading.Thread(target= download,args=('沉默的羔羊',))
# # 想要在子线程中执行任务，必须通过线程对象调用start方法才行
# t2.start()
print('==========')
02-面向对象的多线程技术
1.声明一个类继承自Thread类
2.将需要在子线程中执行的任务放到run方法中
3.在需要子线程的位置去创建这个类的对象，然后用对象调用start方法去执行run中的任务
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())
if __name__ == '__main__':
print('==========')
t1 = DownloadThread('西虹市首富')
t1.start()
t2 = DownloadThread('黑客帝国')
t2.start()
print('+-+-+-+-+-')
03-join方法的使用
如果希望某个线程结束后才进行的操作，就用那个线程调用join函数
from threading import Thread
from random import randint
import time
import datetime
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())
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)
04-线程间的数据共享
同步锁（RLock）和互斥锁(Lock)
模拟多个人对同一个账号进行操作
import time
from threading import Thread,Lock
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('当前余额：%d'% self.balance)
if __name__ == '__main__':
# 创建账号
account = Account(1000)
# account.save_money(200)
# account.save_money(100)
# account.show_balance()
当多个线程对一个数据进行操作时，可能会出现数据混乱的问题
t1 = Thread(target= account.save_money,args= (200,))
t2 = Thread(target=account.save_money, args=(300,))
t1.start()
t2.start()
