随笔- 71 文章- 17 评论- 0 阅读- 5341

一、验证GIL存在

有了GIL的存在，同一时刻同一进程中只有一个线程被执行

反推验证GIL的存在（多个线程同时执行会是如何）

 from threading import Thread
 
money = 100
 
 
def task():
    global money
    money -= 1
 
 
t_list = []
for i in range(100):
    t = Thread(target=task)
    t.start()
    t_list.append(t)  # [线程1 线程2 线程3 ... 线程100]
for t in t_list:
    t.join()
# 等待所有的线程运行结束 查看money是多少
print(money)
'''
线程同时执行，结果不会为 0
上述结果为 0，表明GIL是存在的，线程没有同时执行
'''

二、验证GIL的特点

GIL不会影响程序层面的数据也不会保证它的修改是安全的，要想保证它的修改是安全的得自己加锁

 from threading import Thread,Lock
import time
 
money = 100
mutex = Lock()
 
 
def task():
    mutex.acquire()
    global money
    tmp = money
    time.sleep(0.1)
    money = tmp - 1
    mutex.release()
 
 
t_list = []
for i in range(100):
    t = Thread(target=task)
    t.start()
    t_list.append(t)  # [线程1 线程2 线程3 ... 线程100]
for t in t_list:
    t.join()
# 等待所有的线程运行结束 查看money是多少
print(money)

三、验证python多线程是否有用

情况一：单个CPU和多个CPU
情况二：IO密集型(代码有IO操作)和计算密集型(代码没有IO)

1.单个CPU

	IO密集型	计算密集型
多进程	申请额外的空间，消耗更多的资源	申请额外的空间，消耗更多的资源（总耗时+申请空间+拷贝代码+切换）
多线程	消耗资源相对较少，通过多道技术	消耗资源相对较少，通过多道技术（总耗时+切换）
优势	多线程有优势	多线程有优势

2.多个CPU

	IO密集型	计算密集型
多进程	总耗时（单个进程的耗时+IO+申请空间+拷贝代码）	总耗时（单个进程耗时）
多线程	总耗时（单个进程耗时+IO）	总耗时（多个进程的综合）
优势	多线程有优势	多进程完胜

3.代码示例

计算机密集型：

多线程：30.233906745910645
多进程：5.665567398071289

 from threading import Thread
from multiprocessing import Process
import os
import time
 
 
def work():
    # 计算密集型
    res = 1
    for i in range(1, 100000):
        res *= i
 
 
if __name__ == '__main__':
    # print(os.cpu_count())  # 12  查看当前计算机CPU个数
    start_time = time.time()
    # p_list = []
    # for i in range(12):  # 一次性创建12个进程
    #     p = Process(target=work)
    #     p.start()
    #     p_list.append(p)
    # for p in p_list:  # 确保所有的进程全部运行完毕
    #     p.join()
    t_list = []
    for i in range(12):
        t = Thread(target=work)
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print('总耗时:%s' % (time.time() - start_time))  # 获取总的耗时

IO密集型：

多线程：0.0149583816528320
多进程：0.6402878761291504

 from threading import Thread
from multiprocessing import Process
import os
import time
 
 
def work():
    time.sleep(2)   # 模拟纯IO操作
 
 
if __name__ == '__main__':
    start_time = time.time()
    # t_list = []
    # for i in range(100):
    #     t = Thread(target=work)
    #     t.start()
    # for t in t_list:
    #     t.join()
    p_list = []
    for i in range(100):
        p = Process(target=work)
        p.start()
    for p in p_list:
        p.join()
    print('总耗时:%s' % (time.time() - start_time))

四、死锁现象

互斥锁的使用：先抢锁，后释放锁（实际项目尽量少用）

 from threading import Thread, Lock
import time
 
mutexA = Lock()  # 类名加括号每执行一次就会产生一个新的对象
mutexB = Lock()  # 类名加括号每执行一次就会产生一个新的对象
 
 
class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
 
    def func1(self):
        mutexA.acquire()
        print(f'{self.name}抢到了A锁')
        mutexB.acquire()
        print(f'{self.name}抢到了B锁')
        mutexB.release()
        print(f'{self.name}释放了B锁')
        mutexA.release()
        print(f'{self.name}释放了A锁')
 
    def func2(self):
        mutexB.acquire()
        print(f'{self.name}抢到了B锁')
        time.sleep(1)
        mutexA.acquire()
        print(f'{self.name}抢到了A锁')
        mutexA.release()
        print(f'{self.name}释放了A锁')
        mutexB.release()
        print(f'{self.name}释放了B锁')
 
 
for i in range(10):
    t = MyThread()
    t.start()

五、信号量

1.简介

信号量本质：互斥锁，只不过是多把锁

信号量在不同的知识体系里的意思区别：

在并发编程中，信号量就是多把互斥锁
在Django中，信号量指的是达到某个条件自动触发（中间件）

之前使用Lock产生的是单把锁（类似于单间厕所）

信号量相当于一次性创建多间厕所（类似于公共厕所）

2.代码示例

 from threading import Thread, Lock, Semaphore
import time
import random
 
 
sp = Semaphore(5)  # 一次性产生五把锁
 
 
class MyThread(Thread):
    def run(self):
        sp.acquire()
        print(self.name)
        time.sleep(random.randint(1, 3))
        sp.release()
 
 
for i in range(20):
    t = MyThread()
    t.start()

六、event事件

子进程/子线程之间可以彼此等待彼此

子A运行到某一个代码位置后发信号告诉子B开始运行

 from threading import Thread, Event
import time
 
event = Event()  # 类似于造了一个红绿灯
 
 
def light():
    print('红灯亮着的 所有人都不能动')
    time.sleep(3)
    print('绿灯亮了 油门踩到底 给我冲!!!')
    event.set()
 
 
def car(name):
    print('%s正在等红灯' % name)
    event.wait()
    print('%s加油门 飙车了' % name)
 
 
t = Thread(target=light)
t.start()
for i in range(20):
    t = Thread(target=car, args=('熊猫PRO%s' % i,))
    t.start()

七、池

1.简介

降低程序的执行效率，保证计算机硬件的安全

多进程/多线程：在实际应用中是不可以无限制的开进程和线程，会造成内存溢出受限于硬件水平

2.进程池和线程池

进程池：提前创建好固定个数的进程供程序使用，后续不会再创建
线程池：提前创建好固定个数的线程供程序使用，后续不会再创建

3.代码实例

 from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
from threading import current_thread
import os
import time
 
# pool = ThreadPoolExecutor(5)  # 固定产生五个线程
pool = ProcessPoolExecutor(5)  # 固定产生五个线程
 
 
def task(n):
    # print(current_thread().name)
    print(os.getpid())
    # print(n)
    time.sleep(1)
    return '返回的结果'
 
 
def func(*args, **kwargs):
    print('func', args, kwargs)
    print(args[0].result())
 
 
if __name__ == '__main__':
    for i in range(20):
        # res = pool.submit(task,123)  # 朝池子中提交任务(异步)
        # print(res.result())  # 同步
        # pool.submit(task, 123).add_done_callback(func)
        """异步回调:异步任务执行完成后有结果就会自动触发该机制"""
        pool.submit(task, 123).add_done_callback(func)

八、协程

名称	属性
进程	资源单位
线程	执行单位
协程	单线程下实现并发（效率极高）

1.简介

在代码层面欺骗CPU 让CPU觉得我们的代码里面没有IO操作，实际上IO操作被我们自己写的代码检测，一旦有，立刻让代码执行别的(该技术完全是程序员自己弄出来的，名字也是程序员自己起的)

核心：自己写代码完成切换+保存状态

2.代码示例

 import time
from gevent import monkey;
 
monkey.patch_all()  # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn
 
 
def func1():
    print('func1 running')
    time.sleep(3)
    print('func1 over')
 
 
def func2():
    print('func2 running')
    time.sleep(5)
    print('func2 over')
 
 
if __name__ == '__main__':
    start_time = time.time()
    # func1()
    # func2()
    s1 = spawn(func1)  # 检测代码 一旦有IO自动切换(执行没有io的操作 变向的等待io结束)
    s2 = spawn(func2)
    s1.join()
    s2.join()
    print(time.time() - start_time)  # 8.01237154006958   协程 5.015487432479858

九、协程实现TCP服务端并发

Gevent 是一个第三方库，通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。

 import socket
from gevent import monkey;monkey.patch_all()  # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn
 
 
def communication(sock):
    while True:
        data = sock.recv(1024)
        print(data.decode('utf8'))
        sock.send(data.upper())
 
 
def get_server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8080))
    server.listen(5)
    while True:
        sock, addr = server.accept()  # IO操作
        spawn(communication, sock)
 
s1 = spawn(get_server)
s1.join()

十、总结

怎么不断的提升程序的运行效率：多进程下开多线程，多线程

下开协程

posted on 2022-08-12 16:18 念白SAMA 阅读(22) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 并发编程3

· 并发编程2

· 并发编程-4

· 【2022-08-11】Python并发编程(三)

· 【8.11】并发编程-完结

阅读排行：
· winform 绘制太阳，地球，月球运作规律
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· AI 智能体引爆开源社区「GitHub 热点速览」
· 写一个简单的SQL生成工具
· Manus的开源复刻OpenManus初探

公告

昵称：念白SAMA
园龄： 2年8个月
粉丝： 5
关注： 3

+加关注

2025年3月

日

一

二

三

四

五

六

随笔档案

2022年12月(1)

2022年9月(1)

2022年8月(13)

2022年7月(21)

2022年6月(18)

一、验证GIL存在

二、验证GIL的特点

三、验证python多线程是否有用

1.单个CPU

2.多个CPU

3.代码示例

四、死锁现象

五、信号量

1.简介

2.代码示例

六、event事件

七、池

1.简介

2.进程池和线程池

3.代码实例

八、协程

1.简介

2.代码示例

九、协程实现TCP服务端并发

十、总结

公告

搜索

常用链接

随笔档案

阅读排行榜

	from threading import Thread

	money = 100


	def task():
	global money
	money -= 1


	t_list = []
	for i in range(100):
	t = Thread(target=task)
	t.start()
	t_list.append(t) # [线程1 线程2 线程3 ... 线程100]
	for t in t_list:
	t.join()
	# 等待所有的线程运行结束查看money是多少
	print(money)
	'''
	线程同时执行，结果不会为 0
	上述结果为 0，表明GIL是存在的，线程没有同时执行
	'''

	from threading import Thread,Lock
	import time

	money = 100
	mutex = Lock()


	def task():
	mutex.acquire()
	global money
	tmp = money
	time.sleep(0.1)
	money = tmp - 1
	mutex.release()


	t_list = []
	for i in range(100):
	t = Thread(target=task)
	t.start()
	t_list.append(t) # [线程1 线程2 线程3 ... 线程100]
	for t in t_list:
	t.join()
	# 等待所有的线程运行结束查看money是多少
	print(money)

	from threading import Thread
	from multiprocessing import Process
	import os
	import time


	def work():
	# 计算密集型
	res = 1
	for i in range(1, 100000):
	res *= i


	if __name__ == '__main__':
	# print(os.cpu_count()) # 12 查看当前计算机CPU个数
	start_time = time.time()
	# p_list = []
	# for i in range(12): # 一次性创建12个进程
	# p = Process(target=work)
	# p.start()
	# p_list.append(p)
	# for p in p_list: # 确保所有的进程全部运行完毕
	# p.join()
	t_list = []
	for i in range(12):
	t = Thread(target=work)
	t.start()
	t_list.append(t)
	for t in t_list:
	t.join()
	print('总耗时:%s' % (time.time() - start_time)) # 获取总的耗时

	from threading import Thread, Lock
	import time

	mutexA = Lock() # 类名加括号每执行一次就会产生一个新的对象
	mutexB = Lock() # 类名加括号每执行一次就会产生一个新的对象


	class MyThread(Thread):
	def run(self):
	self.func1()
	self.func2()

	def func1(self):
	mutexA.acquire()
	print(f'{self.name}抢到了A锁')
	mutexB.acquire()
	print(f'{self.name}抢到了B锁')
	mutexB.release()
	print(f'{self.name}释放了B锁')
	mutexA.release()
	print(f'{self.name}释放了A锁')

	def func2(self):
	mutexB.acquire()
	print(f'{self.name}抢到了B锁')
	time.sleep(1)
	mutexA.acquire()
	print(f'{self.name}抢到了A锁')
	mutexA.release()
	print(f'{self.name}释放了A锁')
	mutexB.release()
	print(f'{self.name}释放了B锁')


	for i in range(10):
	t = MyThread()
	t.start()

	from threading import Thread, Lock, Semaphore
	import time
	import random


	sp = Semaphore(5) # 一次性产生五把锁


	class MyThread(Thread):
	def run(self):
	sp.acquire()
	print(self.name)
	time.sleep(random.randint(1, 3))
	sp.release()


	for i in range(20):
	t = MyThread()
	t.start()

	from threading import Thread, Event
	import time

	event = Event() # 类似于造了一个红绿灯


	def light():
	print('红灯亮着的所有人都不能动')
	time.sleep(3)
	print('绿灯亮了油门踩到底给我冲!!!')
	event.set()


	def car(name):
	print('%s正在等红灯' % name)
	event.wait()
	print('%s加油门飙车了' % name)


	t = Thread(target=light)
	t.start()
	for i in range(20):
	t = Thread(target=car, args=('熊猫PRO%s' % i,))
	t.start()

	from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
	from threading import current_thread
	import os
	import time

	# pool = ThreadPoolExecutor(5) # 固定产生五个线程
	pool = ProcessPoolExecutor(5) # 固定产生五个线程


	def task(n):
	# print(current_thread().name)
	print(os.getpid())
	# print(n)
	time.sleep(1)
	return '返回的结果'


	def func(args, *kwargs):
	print('func', args, kwargs)
	print(args[0].result())


	if __name__ == '__main__':
	for i in range(20):
	# res = pool.submit(task,123) # 朝池子中提交任务(异步)
	# print(res.result()) # 同步
	# pool.submit(task, 123).add_done_callback(func)
	"""异步回调:异步任务执行完成后有结果就会自动触发该机制"""
	pool.submit(task, 123).add_done_callback(func)

	import time
	from gevent import monkey;

	monkey.patch_all() # 固定编写用于检测所有的IO操作(猴子补丁)
	from gevent import spawn


	def func1():
	print('func1 running')
	time.sleep(3)
	print('func1 over')


	def func2():
	print('func2 running')
	time.sleep(5)
	print('func2 over')


	if __name__ == '__main__':
	start_time = time.time()
	# func1()
	# func2()
	s1 = spawn(func1) # 检测代码一旦有IO自动切换(执行没有io的操作变向的等待io结束)
	s2 = spawn(func2)
	s1.join()
	s2.join()
	print(time.time() - start_time) # 8.01237154006958 协程 5.015487432479858

	import socket
	from gevent import monkey;monkey.patch_all() # 固定编写用于检测所有的IO操作(猴子补丁)
	from gevent import spawn


	def communication(sock):
	while True:
	data = sock.recv(1024)
	print(data.decode('utf8'))
	sock.send(data.upper())


	def get_server():
	server = socket.socket()
	server.bind(('127.0.0.1', 8080))
	server.listen(5)
	while True:
	sock, addr = server.accept() # IO操作
	spawn(communication, sock)

	s1 = spawn(get_server)
	s1.join()