1. 线程（thread）
- 每个进程默认有一个线程，这个线程叫主线程，其他的进程都叫子线程
2. 线程模块（threading）
- 利用threading模块的Thread类创建子线程
1）threading模块
- 专门提供和线程相关的操作
- import threading
2）current_thread函数
- 获取当前线程
- print(threading.current_thread())
3）Thread类
- Thread类的对象就是线程，所以需要子线程就创建这个类的对象
- Thread(target,args,kwargs)
target：函数, 需要在当前创建的子线程中去调用的函数
args/kwargs：调用target中的函数需要的实参列表
- 创建线程对象：t1 = threading.Thread(target=download, args=('复联5',))
4）start方法
- 开始执行子线程中的任务: 线程对象.start()
- 通过start方法，在子线程中去调用target对应的函数
- t1.start()
5）实例
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())
print(threading.current_thread()) #只是获取当前线程，非必要
# a.创建线程对象
t1 = threading.Thread(target=download, args=('复联5',))
# t1 = threading.Thread(target=download, kwargs={'film_name': '复联5'})
t2 = threading.Thread(target=download, args=('007',))
# b.开始执行子线程中的任务
t1.start()
t2.start()
3. 创建自己的线程类
- 注意：一个进程中如果有多个线程，程序会在所有的线程都结束的时候才结束，发生异常崩溃其实奔溃的是线程，并且其中一个线程崩溃并不影响其他线程运行
1）声明一个类继承Thread
- class DownloadThread(Thread):
2）实现run方法
3）用子类直接创建线程对象
- t1 = DownloadThread('复联4')
4）通过start去执行子线程中的任务
- t1.start()：只有start方法可以开启子线程任务执行run里面的内容
- t1.run()：不能直接调用run方法，因为这样调用的结果是在主线程中执行run里面的内容而不是在子线程
5）实例一
from threading import *
import time
from datetime import datetime
class DownloadThread(Thread):
def __init__(self, film_name):
super().__init__()
self.film_name = film_name
def run(self):
print('开始下载: %s' % self.film_name, datetime.now())
time.sleep(6)
print('结束下载: %s' % self.film_name, datetime.now())
# 用子类直接创建线程对象
t1 = DownloadThread('复联4')
t2 = DownloadThread('长江7号')
# 通过start去执行子线程中的任务
t1.start()
t2.start()
# t1.run() # 不能直接调用run方法,因为这样调用不会在子线程中执行任务
6）实例二：server的多线程功能实现
from socket import *
from threading import *
class ChatThread(Thread):
def __init__(self, connect: socket, address):
super().__init__()
self.connect = connect
self.address = address
def run(self):
while True:
self.connect.send('你好，我是余婷！'.encode())
message = self.connect.recv(1024)
print('%s:%s' % (self.address[0], message.decode(encoding='utf-8')))
connect.close()
server = socket()
server.bind(('10.7.185.82', 8888))
server.listen(512)
while True:
# 接收请求
connect, address = server.accept()
# 给每个请求创建一个线程，来聊天
t = ChatThread(connect, address)
t.start()
4. join方法
- 如果希望某个任务是在某个线程结束后才执行，那就将这个任务的代码放在对应线程对象调用join方法的后面
- 实例
from threading import Thread
from datetime import datetime
import time
from random import randint
class DownloadThread(Thread):
def __init__(self, name, time):
super().__init__()
self.name = name
self.time = time
def run(self):
print('开始下载:%s' % self.name)
time.sleep(self.time)
print('下载结束:%s' % self.name)
t1 = DownloadThread('沉默的羔羊', 3)
t2 = DownloadThread('恐怖游轮', 2)
t2.start()
t1.start()
t1.join()
t2.join()
print('下载完成')
print('=============================')
t1 = DownloadThread('沉默的羔羊', 3)
t2 = DownloadThread('恐怖游轮', 2)
t2.start()
t2.join()
t1.start()
5. 锁的使用（Lock）
1）问题
- 当多个线程同时对一个数据进行读写操作，可能会出现一个线程刚把数据读出来还没来得及写进去，另外一个线程进行读操作的数据安全问题。
(类似多个人上一个厕所，一个人进去了还没出来，另外一个人又进去的问题)
2）解决问题：加锁
- 保证每个数据对应一个锁对象
- 操作数据前加锁，数据操作完成后释放锁
3）实例一
import time
from threading import Thread, Lock
class Account:
def __init__(self, name, tel, balance=50):
self.name = name
self.tel = tel
self.balance = balance
# 关联一个锁对象
self.lock = Lock()
def save_money(self, money):
print('开始存钱')
# 加锁
self.lock.acquire()
value = self.balance
time.sleep(4)
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(5)
if value < money:
print('取钱失败！余额不足')
return
self.balance = value - money
print('取钱成功:%.2f' % self.balance)
# 释放锁
self.lock.release()
acount = Account('余婷', '15300022703', 10000)
# 一个线程去存钱
t1 = Thread(target=acount.save_money, args=(1000,))
# 一个线程去取钱
t2 = Thread(target=acount.draw_money, args=(500,))
t1.start()
t2.start()
4）实例二
import time
from threading import Thread, Lock
share_data = 1000
lock = Lock()
def add_data(value):
lock.acquire()
global share_data
old_data = share_data
time.sleep(4)
share_data = old_data + value
lock.release()
t1 = Thread(target=add_data, args=(200,))
t2 = Thread(target=add_data, args=(300,))
t1.start()
t2.start()
t1.join()
t2.join()
print(share_data)
