【编程小白必看】Python并发编程操作秘籍🔥一文全掌握
文章目录
前言
嘿,小伙伴们!今天我要带大家走进Python并发编程的世界,
特别关注如何使用 Python 的并发编程技术来提高程序的效率。跟着我一起,轻松掌握这些实战技巧!
一、什么是并发编程?
并发编程是指让程序同时执行多个任务的能力。想象一下,就像你在做饭时,一边炒菜一边煮汤,而不是做完一个再做另一个。
二、操作案例
1.使用 threading 模块
使用 threading 模块创建线程。
代码如下(示例):
# 使用 threading 模块
import threading
def print_numbers():
for i in range(1, 6):
print(i)
def print_letters():
for letter in "ABCDE":
print(letter)
t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_letters)
t1.start()
t2.start()
t1.join()
t2.join()
2.使用 Lock 锁
使用 Lock 锁来保护共享资源。
代码如下(示例):
# 使用 Lock 锁
import threading
counter = 0
lock = threading.Lock()
def increment_counter():
global counter
lock.acquire()
counter += 1
lock.release()
threads = []
for _ in range(10):
t = threading.Thread(target=increment_counter)
threads.append(t)
t.start()
for t in threads:
t.join()
print("Counter value:", counter)
3.使用 Queue 队列
使用 Queue 队列来实现线程间通信。
代码如下(示例):
# 使用 Queue 队列
import threading
import queue
def producer(q):
for i in range(5):
q.put(i)
def consumer(q):
while True:
item = q.get()
if item is None:
break
print("Consumed:", item)
q.task_done()
q = queue.Queue()
producer_thread = threading.Thread(target=producer, args=(q,))
consumer_thread = threading.Thread(target=consumer, args=(q,))
producer_thread.start()
consumer_thread.start()
producer_thread.join()
q.join()
q.put(None)
consumer_thread.join()
4.使用 multiprocessing 模块
使用 multiprocessing 模块创建进程。
代码如下(示例):
# 使用 multiprocessing 模块
import multiprocessing
def square(numbers):
for num in numbers:
print(num ** 2)
if __name__ == "__main__":
numbers = [1, 2, 3, 4]
p = multiprocessing.Process(target=square, args=(numbers,))
p.start()
p.join()
5.使用 Pool
使用 Pool 来并行处理任务。
代码如下(示例):
# 使用 Pool
import multiprocessing
def square(x):
return x ** 2
if __name__ == "__main__":
with multiprocessing.Pool(processes=4) as pool:
results = pool.map(square, range(10))
print(results)
6.使用 asyncio 模块
使用 asyncio 模块进行异步编程。
代码如下(示例):
# 使用 asyncio 模块
import asyncio
async def say_after(delay, what):
await asyncio.sleep(delay)
print(what)
async def main():
task1 = asyncio.create_task(say_after(1, 'hello'))
task2 = asyncio.create_task(say_after(2, 'world'))
print(f"started at {time.strftime('%X')}")
# Wait until both tasks are completed (should take
# around 2 seconds.)
await task1
await task2
print(f"finished at {time.strftime('%X')}")
asyncio.run(main())
7.使用 async/await
使用 async/await 关键字简化异步代码。
代码如下(示例):
# 使用 async/await
import asyncio
async def fetch_data():
print("开始获取数据...")
await asyncio.sleep(2)
print("数据获取完成!")
async def main():
await fetch_data()
asyncio.run(main())
8.使用 concurrent.futures 模块
使用 concurrent.futures 模块简化并发编程。
代码如下(示例):
# 使用 concurrent.futures 模块
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
def square(x):
return x ** 2
if __name__ == "__main__":
with ThreadPoolExecutor(max_workers=4) as executor:
results = list(executor.map(square, range(10)))
print(results)
9.使用 contextvars 模块
使用 contextvars 模块处理异步上下文。
代码如下(示例):
# 使用 contextvars 模块
import contextvars
import asyncio
var = contextvars.ContextVar("var")
async def set_var():
var.set("Hello, World!")
print(var.get())
async def get_var():
print(var.get())
async def main():
await set_var()
await get_var()
asyncio.run(main())
10.使用 signal 模块
使用 signal 模块处理信号。
代码如下(示例):
# 使用 signal 模块
import signal
import time
import sys
def signal_handler(signum, frame):
print("Signal received, exiting...")
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
print("Press Ctrl+C to exit.")
while True:
time.sleep(1)
总结
以上就是Python并发编程的一些常用操作,很多操作都是一行代码搞定,真的很简单,编程小白必看。相信你看完之后也能成为并发编程的小能手!如果还有不清楚的地方,欢迎留言提问哦!
希望这篇笔记对你有所帮助,快去试试吧!