在介绍Python中的线程之前，先明确一个问题，Python中的多线程是假的多线程！
为什么这么说，我们先明确一个概念，全局解释器锁（GIL）
什么是GIL
Python代码的执行由Python虚拟机（解释器）来控制,同时只有一个线程在执行。对Python虚拟机的访问由全局解释器锁（GIL）来控制，正是这个锁能保证同时只有一个线程在运行。
为什么要GIL
为了线程间数据的一致性和状态同步的完整性，（例如：线程2需要线程1执行完成的结果，然而线程2又比线程1执行时间短，线程2执行完成，线程1仍然还在执行，这就是数据的同步性）
GIL的影响
只有一个线程在运行，无法使用多核。
-
在多线程环境中，Python虚拟机按照以下方式执行。
1.设置GIL。
2.切换到一个线程去执行。
3.运行。
4.把线程设置为睡眠状态。
5.解锁GIL。
6.再次重复以上步骤。
比方我有一个4核的CPU，那么这样一来，在单位时间内每个核只能跑一个线程，然后时间片轮转切换。
但是Python不一样，它不管你有几个核，单位时间多个核只能跑一个线程，然后时间片轮转。
执行一段时间后让出，多线程在Python中只能交替执，10核也只能用到1个核
例如：
from threading import Thread
def loop():
while True:
print("亲爱的，我错了，我能吃饭了吗?")
if __name__ == \'__main__\':
for i in range(3):
t = Thread(target=loop)
t.start()
while True:
pass
而如果我们变成进程呢？cpu --100%
from multiprocessing import Process
def loop():
while True:
print("亲爱的，我错了，我能吃饭了吗?")
if __name__ == \'__main__\':
for i in range(3):
t = Process(target=loop)
t.start()
while True:
pass
多线程怎么使用多核
- 1、重写python编译器(官方cpython)如使用：PyPy解释器
- 2、调用C语言的链接库
cpu密集型(计算密集型)、I/O密集型
- 计算密集型任务由于主要消耗CPU资源，代码运行效率至关重要，C语言编写
- IO密集型，涉及到网络、磁盘IO的任务都是IO密集型任务，这类任务的特点是CPU消耗很少，任务的大部分时间都在等待IO操作完成99%的时间花费在IO上，脚本语言是首选，C语言最差。
2、创建多线程
def doSth(arg):
# 拿到当前线程的名称和线程号id
threadName = threading.current_thread().getName()
tid = threading.current_thread().ident
for i in range(5):
print("%s *%d @%s,tid=%d" % (arg, i, threadName, tid))
time.sleep(2)
1、使用_thread.start_new_thread开辟子线程
def simpleThread():
# 创建子线程，执行doSth
# 用这种方式创建的线程为【守护线程】（主线程死去“护卫”也随“主公”而去）
_thread.start_new_thread(doSth, ("拍森",))
mainThreadName = threading.current_thread().getName()
print(threading.current_thread())
# 5秒的时间以内，能看到主线程和子线程在并发打印
for i in range(5):
print("劳资是主线程@%s" % (mainThreadName))
time.sleep(1)
# 阻塞主线程，以使【守护线程】能够执行完毕
while True:
pass
2、 通过创建threading.Thread对象实现子线程
def threadingThread():
# 默认不是【守护线程】
t = threading.Thread(target=doSth, args=("大王派我来巡山",)) # args=(,) 必须是元组
# t.setDaemon(True) # 设置为守护线程
t.start() # 启动线程，调用run()方法
t.join() # 等待
3、通过继承threading.Thread类，进而创建对象实现子线程
class MyThread(threading.Thread):
def __init__(self, name, task, subtask):
super().__init__()
self.name = name # 覆盖了父类的name
self.task = task # MyThread自己的属性
self.subtask = subtask
# 覆写父类的run方法，
# run方法以内为【要跑在子线程内的业务逻辑】(thread.start()会触发的业务逻辑)
def run(self):
for i in range(5):
print("[%s]并[%s] *%d @%s" % (self.task, self.subtask, i, threading.current_thread().getName()))
time.sleep(2)
def classThread():
mt = MyThread("小分队I", "巡山", "扫黄")
mt.start() # 启动线程
4、几个重要的API
并行 : 多个任务同时进行,但python多线程不允许,多进程是允许的
并发 : 多个任务在单个CPU交替执行 ,
串行 : 任务在CPU之间快速切换 , 交替执行
def importantAPI():
print(threading.currentThread()) # 返回当前的线程变量
# 创建五条子线程
t1 = threading.Thread(target=doSth, args=("巡山",))
t2 = threading.Thread(target=doSth, args=("巡水",))
t3 = threading.Thread(target=doSth, args=("巡鸟",))
t1.start() # 开启线程
t2.start()
t3.start()
print(t1.isAlive()) # 返回线程是否活动的
print(t2.isDaemon()) # 是否是守护线程
print(t3.getName()) # 返回线程名
t3.setName("巡鸟") # 设置线程名
print(t3.getName())
print(t3.ident) # 返回线程号
# 返回一个包含正在运行的线程的list
tlist = threading.enumerate()
print("当前活动线程：", tlist)
# 返回正在运行的线程数量（在数值上等于len(tlist)）
count = threading.active_count()
print("当前活动线程有%d条" % (count))
3、线程冲突
\'\'\'
【线程冲突】示例：
多个线程并发访问同一个变量而互相干扰
互斥锁
状态：锁定/非锁定
#创建锁
lock = threading.Lock()
#锁定
lock.acquire()
#释放
lock.release()
\'\'\'
\'\'\'
互相锁住对方线程需要的资源，造成死锁局面
递归锁，用于解决死锁的问题,可重复锁
\'\'\'
import threading
import time
money = 0
# CPU分配的时间片不足以完成一百万次加法运算，
# 因此结果还没有被保存到内存中就被其它线程所打断
def addMoney():
global money
for i in range(1000000):
money += 1
print(money)
# 创建线程锁
lock = threading.Lock()
def addMoneyWithLock():
# print("addMoneyWithLock")
time.sleep(1)
global money
# print(lock.acquire())
# if lock.acquire():
# for i in range(1000000):
# money += 1
# lock.release()
# 独占线程锁
with lock: # 阻塞直到拿到线程锁
# -----下面的代码只有拿到lock对象才能执行-----
for i in range(1000000):
money += 1
# 释放线程锁，以使其它线程能够拿到并执行逻辑
# ----------------锁已被释放-----------------
print(money
# 5条线程同时访问money变量，导致结果不正确
def conflictDemo():
for i in range(5):
t = threading.Thread(target=addMoney)
t.start()
# 通过线程同步（依次执行）解决线程冲突
def handleConflictBySync():
for i in range(5):
t = threading.Thread(target=addMoney)
t.start()
t.join() # 一直阻塞到t运行完毕
# 通过依次独占线程锁解决线程冲突
def handleConflictByLock():
# 并发5条线程
for i in range(5):
t = threading.Thread(target=addMoneyWithLock)
t.start()
if __name__ == \'__main__\':
# conflictDemo()
# handleConflictBySync()
handleConflictByLock()
4、使用Semaphore调度线程：控制最大并发量
\'\'\'
使用Semaphore调度线程：控制最大并发量
\'\'\'
import threading
import time
# 允许最大并发量3
sem = threading.Semaphore(3)
def doSth(arg):
with sem:
tname = threading.current_thread().getName()
print("%s正在执行【%s】" % (tname, arg))
time.sleep(1)
print("-----%s执行完毕!-----\\n" % (tname))
time.sleep(0.1)
if __name__ == \'__main__\':
# 开启10条线程
for i in range(10):
threading.Thread(target=doSth, args=("巡山",), name="小分队%d" % (i)).start()
pass