06_多线程
1.线程概述
1.线程是实现多任务编程的一种方法,可以使用计算机多核资源,是计算机核心分配的最小单位,线程由代码段,数据段,和TCB(线程控制块)组成
2.线程又称为轻量级进程,在创建和删除时消耗的计算机资源小,理论上创建和销毁线程的消耗是创建和销毁进程消耗的二十分之一
3.一个进程中的所有线程共享进程的空间资源(空间,全局变量,分配的内存等),进程中每个线程有自己的特有属性,如指令集TID等
4.多线程程序的执行顺序是不确定的,主线程会等待所有的子线程结束后才结束
5.计算机开启的线程数量建议: CPU核数 * 5
2.threading模块语法概述
import threadingt
= thread.Thread() # 创建线程并返回线程对象参数:
target: 线程函数
args: 给线程函数的位置参数(类型为元组)
kwargs: 给线程函数的字典传参(类型为字典)
name: 给线程取名字(默认为Thread-1)
t.start(): 启动线程
t.join(timeout): 回收线程
t.is_alive(): 查看线程状态
t.name: 查看线程名称
threading.currentThread(): 得到线程对象
t.setName(): 设置线程名称
t.daemon = True: 守护线程,默认为False主线程执行完毕不会影响分支线程的执行,True则表示主线程执行完毕其它线程也会终止
设置方法: t.daemon = True 或者 t.setDaemon(True)
t.isDaemon(True): 判断daemon属性是 True or False
3.线程属性示例
from threading import Threadfrom threading import currentThreadfrom time import sleepdef func(sec):print("线程属性测试")sleep(sec)
print("%s线程结束" % currentThread().getName())def main():thread
= list()for i in range(3):t
= Thread(name="t-" + str(i), target=func, args=(5,))# 设置deamon属性为True,此时主线程结束,子线程也会结束# t.setDaemon(True) # 默认为False,主线程等待子线程结束
print("isDaemon", t.isDaemon())
# 也可以在定义后设置线程名称
# t.setName = "t-" + str(i)
t.start()
thread.append(t)
for i in thread:
i.join(1)
print("thread name:", i.name)
print("alive:", i.is_alive())
print("主线程结束")
if__name__ == "__main__":
main()
"""执行结果
isDaemon False
线程属性测试
isDaemon False
线程属性测试
isDaemon False
线程属性测试
thread name: t-0
alive: True
thread name: t-1
alive: True
thread name: t-2
alive: True
主线程结束
t-0线程结束
t-2线程结束
t-1线程结束
"""
4.线程定时器
from threading import Timer # 定时器def func():
print("此生一入IT们,从此不爱任何人!")
Timer(2.5, func).start()
# Timer(time, func)
# time: 睡眠的时间,以秒为单位
# func: 睡眠时间之后,需要执行的任务
5.验证守护线程
from threading import Threadimport timedef func():time.sleep(
2)print(123)def func1():time.sleep(
1)print("abc")# 守护线程不是根据主线程的代码执行结束而结束,而是根据主线程执行结束才结束#
主线程会等待普通线程执行结束再结束,守护线程会等待主线程结束再结束,所以一般把不重要的事情设置为守护线程#
守护进程是根据主进程的代码执行完毕,守护进程就结束if__name__ == "__main__":
t = Thread(target=func)
t.daemon = True
t.start()
t1 = Thread(target=func1)
t1.start()
print(456)
6.自定义线程函数
# 将函数作为实参传递给线程类,通过线程类的实例化对象启动线程import threading
import time
def sing():
"""唱歌5秒钟"""
for i in range(5):
print("---正在唱歌---%s" % i)
time.sleep(1)
def dance():
"""跳舞10秒钟"""
for i in range(10):
print("---正在跳舞---%s" % i)
time.sleep(1)
def main():
# 创建线程
t1 = threading.Thread(target=sing)
t2 = threading.Thread(target=dance)
# 启动线程
t1.start()
t2.start()
for i in range(15):
# 查看当前线程数量
print(threading.enumerate())
time.sleep(1)
t1.join() # 等待回收线程
t2.join() # 等待回收线程
if__name__ == "__main__":
main()
7.自定义线程类
1.继承Thread类重写 run 方法
import threadingimport time# threading.Thread类有一个run方法,用于定义线程的功能函数,可以在自己的线程类中覆盖该方法#
而创建自己的线程实例后,通过Thread类的start方法启动该线程class MyThread(threading.Thread):
def run(self):
for i in range(3):
time.sleep(1)
msg = "I"m "+self.name+" @ "+str(i) #name属性中保存的是当前线程的名字
print(msg)
if__name__ == "__main__":
t = MyThread()
t.start()
2.继承Thread类重写 run 方法和 __init__ 方法
from threading import Threadfrom time import ctimefrom time import sleepclass MyThread(Thread):def__init__(self, func, args, name="Tedu"):super().
__init__()self.func
= funcself.args
= argsself.name
= namedef run(self):self.func(
*self.args)@staticmethod
# 声明此方法是静态方法def plary(file, sec):
for _ in range(sec):
print("%s: %s" % (file, ctime()))
sleep(sec)
def main():
t = MyThread(MyThread.plary, ("echo", 3))
t.start()
t.join()
if__name__ == "__main__":
main()
"""
echo: Sun Jul 19 23:13:55 2020
echo: Sun Jul 19 23:13:58 2020
echo: Sun Jul 19 23:14:01 2020
"""
8.Python线程的全局解释器锁(GIL)
全局解释器锁-产生的原因
GIL是CPython解释器存在的问题
Python支持多线程 同步互斥 加锁 超级锁 但在同一时刻解释器只能解释一个线程
大量的Python库为了省事沿用了这种方法导致了Python多线程效率低下
全局解释器锁-用htop命令查看CPU占有率验证
1.单线程死循环
def main():# 主线程死循环while True:
pass
if__name__ == "__main__":
main()
2.多线程死循环
import threading# 子线程死循环def test():
pass
def main():
t1 = threading.Thread(target=test)
t1.start()
# 主线程死循环
while True:
pass
if__name__ == "__main__":
main()
3.多进程死循环
import multiprocessing# 子进程死循环def test():
pass
def main():
p1 = multiprocessing.Process(target=test)
p1.start()
# 主进程死循环
while True:
pass
if__name__ == "__main__":
main()
全局解释器锁-通过计算密集耗时和IO操作耗时验证
import timeimport threadingimport multiprocessing# 计算密集def calculation(num, x=1, y=1):
for _ in range(num):
x += 1
y += 1
# IO密集-读写
def io_write_read(num):
# IO密集-写
f = open("./test.txt", "w")
for _ in range(num):
f.write("hello world!
")
f.close()
# IO密集-读
f = open("./test.txt", "r")
for _ in range(num):
f.readline()
f.close()
# 单任务耗时
def single_task_time(num, func):
t_start = time.time()
for _ in range(10):
func(num)
t_end = time.time() - t_start
print("单线程CPU执行1亿次%s耗时: %s" % (func.__name__, t_end))
# 多线程耗时
def threading_time(num, func):
t_start = time.time()
counts = list()
for _ in range(10):
# t = threading.Thread(target=func, args=(num,), kwargs={"x": 1, "y": 1})
t = threading.Thread(target=func, args=(num,))
t.start()
counts.append(t)
for i in counts:
i.join()
t_end = time.time() - t_start
print("10个线程CPU执行1亿次%s耗时: %s" % (func.__name__, t_end))
# 多进程耗时
def multiprocessing_time(num, func):
t_start = time.time()
counts = list()
for _ in range(10):
p = multiprocessing.Process(target=func, args=(num,))
p.start()
counts.append(p)
for i in counts:
i.join()
t_end = time.time() - t_start
print("10个进程CPU执行1亿次%s耗时: %s" % (func.__name__, t_end))
def main():
# 单线程耗时
single_task_time(5000000, calculation) # 单线程CPU执行1亿次calculation耗时: 5.152180910110474
single_task_time(5000000, io_write_read) # 单线程CPU执行1亿次io_write_read耗时: 22.120678186416626
# 多线程耗时
threading_time(5000000, calculation) # 10个线程CPU执行1亿次calculation耗时: 5.205517053604126
threading_time(5000000, io_write_read) # 10个线程CPU执行1亿次io_write_read耗时: 22.218310356140137
# 多进程耗时
multiprocessing_time(5000000, calculation) # 10个进程CPU执行1亿次calculation耗时: 1.7116732597351074
multiprocessing_time(5000000, io_write_read) # 10个进程CPU执行1亿次io_write_read耗时: 6.813052177429199
if__name__ == "__main__":
main()
"""执行结果
单线程CPU执行1亿次calculation耗时: 5.335744142532349
单线程CPU执行1亿次io_write_read耗时: 21.98353886604309
10个线程CPU执行1亿次calculation耗时: 5.344666814804077
10个线程CPU执行1亿次io_write_read耗时: 22.28637194633484
10个进程CPU执行1亿次calculation耗时: 1.8069920539855957
10个进程CPU执行1亿次io_write_read耗时: 7.141486167907715
"""
全局解释器锁-解决方法
1.不使用多线程,使用多进程
2.不使用C C++做的解释器,用 C# Java
3.Python多线程适合高用时的网络IO操作,不适用CPU密集型程序
4.使用其它语言实现多线程,Python去调用
GIL解决方案示例-C语言写子线程执行的函数由Python调用
loop.c文件代码
#include<stdio.h>void DeadLoop()
{
while(1)
{
;
}
}
int main(int argc, char **argv)
{
printf("start DeadLoop
");
DeadLoop();
return0;
}
命令行下编译C语言写的代码
gcc loop.c # 编译成功后当前目录先会生成一个a.out的可执行文件
gcc loop.c -shared -o libdead_loop.so # 执行命令把c语言文件编译成一个动态库文件
./a.out # 执行文件
Python调用编译后的C语言的动态库文件
import ctypesimport threadingdef main():# 加载动态库lib = ctypes.cdll.LoadLibrary("libdead_loop.so")
# 创建一个子线程,让子线程执行C语言写的死循环函数
t = threading.Thread(target=lib.DeadLoop)
t.start()
if__name__ == "__main__":
main()
9.多线程-udp聊天器
import socketimport threadingdef send_msg(udp_socket):"""获取键盘数据,并将其发送给对方"""while True:
# 1. 从键盘输入数据
msg = input("
请输入要发送的数据:")
# 2. 输入对方的ip地址
dest_ip = input("
请输入对方的ip地址:")
# 3. 输入对方的port
dest_port = int(input("
请输入对方的port:"))
# 4. 发送数据
udp_socket.sendto(msg.encode("utf-8"), (dest_ip, dest_port))
def recv_msg(udp_socket):
"""接收数据并显示"""
while True:
# 1. 接收数据
recv_msg = udp_socket.recvfrom(1024)
# 2. 解码
recv_ip = recv_msg[1]
recv_msg = recv_msg[0].decode("utf-8")
# 3. 显示接收到的数据
print(">>>%s:%s" % (str(recv_ip), recv_msg))
def main():
# 1. 创建套接字
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 2. 绑定本地信息
udp_socket.bind(("", 7890))
# 3. 创建一个子线程用来接收数据
t = threading.Thread(target=recv_msg, args=(udp_socket,))
t.start()
# 4. 让主线程用来检测键盘数据并且发送
send_msg(udp_socket)
if__name__ == "__main__":
main()
10.多线程-简单tcp服务器
from socket import *import os
import sys
from threading import Thread
def client_handler(c):
try:
print("子线程接收%s客户端的请求" % str(c.getpeername()))
while True:
data = c.recv(1024)
ifnot data:
break
print(data.decode("utf-8"))
c.send(b"receive your message")
except (KeyboardInterrupt, SystemError):
raise
except Exception as e:
print(e)
# 关闭客户端套接字
c.close()
def main():
# 创建套接字
s = socket()
# 端口重用
s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
# 绑定本地信息
s.bind(("", 7890))
# 监听
s.listen(128)
print("主线程%d等待客户端的链接" % os.getpid())
while True:
try:
c, addr = s.accept()
except KeyboardInterrupt:
raise
except Exception as e:
print(e)
continue
t = Thread(target=client_handler, args=(c,))
t.setDaemon(True) # 主线程执行完毕其它线程也会终止
t.start()
# 关闭监听套接字
s.close()
if__name__ == "__main__":
main()
11.多线程-简单tcp服务器的测试客户端
import socketdef main():# 创建数据流套接字tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务器
server_ip = input("请输入要连接的服务器的ip:")
serve_port = int(input("请输入要连接的服务器的port:"))
server_addr = (server_ip, serve_port)
tcp_client_socket.connect(server_addr)
# 发送数据
send_data = input("请输入要发生的数据:")
tcp_client_socket.send(send_data.encode("utf-8"))
# 接收服务器发送过来的数据
recv_data = tcp_client_socket.recv(1024)
print("接收到的数据为:%s" % recv_data.decode("utf-8"))
# 关闭套接字
tcp_client_socket.close()
if__name__ == "__main__":
main()
以上是 06_多线程 的全部内容， 来源链接： utcz.com/z/529972.html
