【编程小白必看】Python并发编程操作秘籍一文全掌握

【编程小白必看】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并发编程的一些常用操作，很多操作都是一行代码搞定，真的很简单，编程小白必看。相信你看完之后也能成为并发编程的小能手！如果还有不清楚的地方，欢迎留言提问哦！
希望这篇笔记对你有所帮助，快去试试吧！