每个进程默认都有一个线程，默认的这个线程叫主线程；其他线程都叫子线程
import time
from datetime import datetime
import threading # 专门提供和线程相关的操作
def download(film_name):
print('开始下载：%s'%film_name, datetime.now())
time.sleep(5)
print('%s下载完成'%film_name, datetime.now())
1.单线程下载两个电影
在一个线程里面下载两个电影，时间是两个电影下载的总和
download('复联4')
download('007')
2.线程模块
'''
- threading.current_thread() --- 获取当前线程
'''
print(threading.current_thread())
'''
- thread 类
Thread 类的对象就是线程，所有需要子线程就创建这个类的对象
Thread(target,args, kwargs)
target --- 函数，需要在子线程中调用的函数
args/kwargs --- 调用target中的函数需要的实参列表
'''
创建线程对象
t1 = threading.Thread(target=download, args=(('复联4',)))
t2 = threading.Thread(target=download, args=('007',))
执行子线程中的任务：线程对象.start()
'''
通过start()方法，在子线程中去调用target对应的函数
t1.start()
t2.start()
from threading import *
import time
from datetime import datetime
'''
- 声明一个类继承Thread
2） 实现run方法，这个方法中的任务就是需要在子线程中执行的任务
'''
创建自己的线程类
class DownloadThread(Thread):
def __init__(self, name):
super().__init__()
self.name = name
def run(self):
print('开始下载：%s'% self.name, datetime.now())
time.sleep(3)
print('结束下载：%s'% self.name, datetime.now())
# print(current_thread())
# print('在子线程中执行的代码')
3) 用子类直接创建线程对象
t1 = DownloadThread('长江七号')
t2 = DownloadThread('长江七2431号')
4） 通过start()去执行子线程中的任务
t1.start()
t2.start()
t1.run() # 不能直接用run方法调用，这个是在主线程上执行的
'''
注意: 一个进程中如果有多个线程，程序会在所有的而现场都结束时才结束
发生异常奔溃 其实奔溃的是线程不是进程
'''
from threading import Thread
from datetime import datetime
import time
from random import *
class DownloadThread(Thread):
def __init__(self, name ):
super().__init__()
self.name = name
def run(self):
print('开始下载：%s' % self.name)
time.sleep(randint(5, 10))
print('接收下载：%s' % self.name)
t1 = DownloadThread('越狱')
t2 = DownloadThread('猫和老鼠')
t1.start()
t2.start()
1 . join
如果希望某个任务是在某个线程结束后才执行，那就将这个任务的代码放在 线程对象调用join方法的后面
'''
t1.join()
print('下载完成')
from threading import Thread, Lock
import time
锁的使用：
'''
1.问题：
当多个线程同时对一个数据进行读写操作的时候，
可能会出现一个线程刚把数据读出来还没有写入，另外一个线程已经开始读操作
而出现的数据安全问题
2.解决 --- 加锁
1） 保证每个数据对应一个锁对象
2） 数据操作前，先给数据加锁
3） 操作完成后，给数据解锁（释放锁）
'''
class Account:
def __init__(self, name, tel, balance):
self.name = name
self.tel = tel
self.balance = balance
# 关联一个锁对象
self.lock = Lock()
def save_money(self, money):
# 给数据上锁
self.lock.acquire()
value = self.balance
time.sleep(3) # 数钱
self.balance = value + money
print('存钱成功:%.2f' % self.balance)
self.lock.release()
def draw_money(self, money):
print('开始取钱')
self.lock.acquire()
value = self.balance
time.sleep(3)
if value < money:
print('取钱失败，余额不足')
return
self.balance = value - money
print('取钱成功:%.2f' % self.balance)
self.lock.release()
acount = Account('小王','1810001111', 10000)
# 一个线程去存钱
t1 = Thread(target=acount.save_money, args=(1000,))
# 一个线程去取钱
t2 = Thread(target=acount.draw_money, args=(500,))
t1.start()
t2.start()
print('-============================')
data =1000
lock = Lock()
def adddata(num):
lock.acquire()
global data
old_data = data
time.sleep(2)
data = old_data + num
lock.release()
t1 = Thread(target=adddata, args=(500,))
t2 = Thread(target=adddata, args=(99,))
t1.start()
t2.start()
t1.join()
t1.join()
print(adddata)