速战速决 Python - python 标准库: 多线程和线程同步，异步编程，多进程，多进程数据共享，多进程数据通信

速战速决 Python https://github.com/webabcd/PythonSample
作者 webabcd

速战速决 Python - python 标准库: 多线程和线程同步，异步编程，多进程，多进程数据共享，多进程数据通信

示例如下:

standardLib/thread.py

# 通过 import threading 实现多线程（注：一个进程同一个时刻只有一个线程在执行，要想利用多核 cpu 则需要用多进程）

import threading
import time
from threading import Timer

# 继承 threading.Thread
class MyThread(threading.Thread):

    def __init__(self, threadName):
        threading.Thread.__init__(self)
        self.name = threadName

    # 需要在新开线程中执行的逻辑
    def run(self):
        myPrint(self.name + " 开始")

        temp = 0
        start = time.perf_counter() # 获取设备开机到现在经过的秒数
        while True:
            if temp < 10:
                myPrint(self.name + " 运行中")
                time.sleep(0.2) # 阻塞 0.2 秒
                temp += 1
            else:
                break

        end = time.perf_counter()
        myPrint(f"{self.name} 运行了 {end-start} {start}秒，退出")

# 通过 threading.Lock() 实现线程同步
lock = threading.Lock()
def myPrint(message):
    # 获取锁
    lock.acquire()
    print(message) # 自己可以测试一下，不用锁的话打印会比较乱，用了锁就不会了
    # 释放锁
    lock.release()


# 创建新线程
thread1 = MyThread("thread_1")
thread2 = MyThread("thread_2")
thread3 = MyThread("thread_3")

# 启动新线程
thread1.start()
thread2.start()
thread3.start()

# 在当前线程等待新开线程执行完毕
thread1.join()
thread2.join()
thread3.join()



def after():
    print('after')
# 通过 timer 实现在指定时间后执行指定函数的功能
timer = Timer(1, after)
timer.start()
timer.join()

standardLib/async.py

# 本例用于演示如何通过 async/await 实现异步编程
# 协程相当于轻量级的线程（注：一个进程同一个时刻只有一个协程在执行，要想利用多核 cpu 则需要用多进程）

import asyncio

# 通过 async 修饰的函数支持异步执行
async def func1():
    print('coroutine1')
async def func2():
    print('coroutine2')
# 构造需要并行执行的异步函数列表
task = [func1(), func2()]
# 创建事件循环
loop = asyncio.new_event_loop()
# 阻塞，直至所有异步函数执行完成
loop.run_until_complete(asyncio.wait(task))
# 关闭事件循环
loop.close()



# async 标记的函数就是一个 coroutine，你可以 await 它
async def func3(name, delay):
    await asyncio.sleep(delay)
    print(name)
async def sample1():
    # await 一个 async 函数，直到它执行完毕
    await func3("i", 1) # 注：这里直接执行 func3("i", 1) 是不可以的，如果需要执行一个 async 函数且不需要等待，则可以 asyncio.create_task(func3("i", 1))
    await func3("j", 1)
    await func3("k", 1)

    # 并行执行多个异步函数
    await asyncio.gather(
        func3("a", 3),
        func3("b", 2),
        func3("c", 1),
    )
# 阻塞，直至指定的异步函数执行完成（不需要手写事件循环）
asyncio.run(sample1())



async def sample2():
    # 创建一个异步任务并立刻并行执行（下面的 task1,task2,task3 会并行执行）
    task1 = asyncio.create_task(func3("x", 1))
    task2 = asyncio.create_task(func3("y", 1))
    task3 = asyncio.create_task(func3("z", 1))
    # 阻塞，直至 task1,task2,task3 执行完成
    await task1
    await task2
    await task3
# 阻塞，直至指定的异步函数执行完成
asyncio.run(sample2())

standardLib/process.py

# 本例用于演示 python 的多进程
# 
# 在 cpython 解释器中，GIL 是一把互斥锁，用来保证进程中同一个时刻只有一个线程在执行
# 所以你即使在一个进程中开了多线程，他们也无法并行执行
#
# coroutine(async/awawit) 要比 thread 简单，并且一个进程中同一个时刻只有一个线程或协程在执行，他们的运行效率没区别，所以尽量都用 coroutine
# 一个进程只能在一个核上运行，如果要充分利用多核 cpu 则需要用多进程
#
# io（网络请求，硬盘存储等）密集型建议用 coroutine，因为它的 cpu 占用率不高，一个核也足够支撑多个 io 任务的同时高效运行
# 计算密集型建议用多进程，否则会因为单核 cpu 占用极高，而阻塞其他线程或协程的运行

import multiprocessing
import time
import os

def func1(i, lock):
    # 获取锁
    lock.acquire()
    print(i, os.getpid())
    # 释放锁
    lock.release()
    time.sleep(1)

# 通过 Process() 开启多进程
def sample1():
    now = time.time()
    l=[]

    # 通过 multiprocessing.Lock() 实现进程同步
    # 需要把这个 lock 传给每个进程，然后在每个进程里 acquire/release
    lock = multiprocessing.Lock()
    for i in range(10):
        p = multiprocessing.Process(target=func1, args=(i,lock))
        p.daemon = True # 是否是守护进程
        p.start()
        l.append(p)

    for p in l:
        p.join() # 阻塞并等待指定的进程执行完毕
        # 强制杀死指定的进程
        # p.kill()

    print('sample1 ok', time.time() - now)



def func2(i, lock):
    # 获取锁
    lock.acquire()
    print(i, os.getpid())
    # 释放锁
    lock.release()
    time.sleep(1)

# 通过进程池开启多进程
def sample2():
    now = time.time()

    # 通过 multiprocessing.Manager().Lock() 实现进程同步
    # 注：在 multiprocessing.Pool() 中不能用 multiprocessing.Lock()
    lock = multiprocessing.Manager().Lock()
    # 注：在 multiprocessing.Pool() 中创建的进程只能是用户进程，而不能创建为守护进程
    pool = multiprocessing.Pool(processes=2) # 池中最大进程数
    for i in range(10):
        pool.apply_async(func=func2, args=(i,lock)) # 从池中申请进程，如果暂时无可用的进程就排队等待

    pool.close() # 关闭进程池，关闭后就不能再申请了
    pool.join() # 阻塞并等待池中进程全部执行完毕

    print('sample2 ok', time.time() - now)


if __name__ == '__main__':
    sample1()
    sample2()


# 另外，关于进程同步，除了 multiprocessing.Lock() 之外，还有
# multiprocessing.Semaphore()
#   可以将 Semaphore 理解为一个许可证中心，该许可证中心的许可证数量是有限的
#   进程想要执行就要先从许可证中心获取一个许可证（如果许可证中心的许可证已经发完了，那就等着，等着其它进程归还许可证），执行完了再还回去
# multiprocessing.Barrier()
#   有个屏障，当所有参与者都到达屏障后，屏障解除

standardLib/process_share.py

# 本例用于演示如何在 python 的多进程中做数据共享

import multiprocessing
from multiprocessing import shared_memory
from ctypes import c_char_p
import os

def func1(i, lock, sm_name):
    lock.acquire()
    # 根据指定的名称获相关的 SharedMemory 对象
    sm = shared_memory.SharedMemory(sm_name)

    # 获取共享内存中的数据
    s = bytes(sm.buf[0:]).decode().strip("\x00")
    i = 0 if s == '' else int(s)
    i += 1
    b = str(i).encode()
    # 设置共享内存中的数据
    sm.buf[0:len(b)] = b

    # 关闭共享内存（数据不会被销毁，可以随时再打开）
    sm.close()
    lock.release()

# 通过 SharedMemory() 在多进程之间共享内存
def sample1():
    l=[]

    # 创建一个新的 SharedMemory 实例，大小为 256 字节
    sm = shared_memory.SharedMemory(create=True, size=256)
    lock = multiprocessing.Lock()
    for i in range(10):
        p = multiprocessing.Process(target=func1, args=(i,lock,sm.name))
        p.daemon = True
        p.start()
        l.append(p)
    for p in l:
        p.join()

    # 获取共享内存中的数据
    result = bytes(sm.buf[0:]).decode().strip("\x00")
    # 关闭共享内存（数据不会被销毁，可以随时再打开）
    sm.close()
    # 释放共享内存（数据会被销毁）
    sm.unlink()

    print('sample1 ok', result)



def func2(i, lock,v_i, v_d,v_c_char_p,m_dict,m_list):
    with v_i.get_lock(): # 支持通过 get_lock() 加锁
        v_i.value += 1
    with v_d.get_lock(): # 支持通过 get_lock() 加锁
        v_d.value += 1.1

    # 需要手动加锁
    lock.acquire()
    v_c_char_p.value += str(i)
    m_dict["k"] += str(i)
    m_list.append(i)
    lock.release()

# 通过 multiprocessing.Value() 和 multiprocessing.Manager() 在多进程之间共享整型，浮点型，字符串，字典，列表等数据
def sample2():
    v_i = multiprocessing.Value('i', 0) # 整型
    v_d = multiprocessing.Value('d', 0.0) # 浮点型
    v_c_char_p = multiprocessing.Manager().Value(c_char_p, "hello") # 字符串
    m_dict = multiprocessing.Manager().dict() # 字典表
    m_dict["k"] = "hello"
    m_list = multiprocessing.Manager().list() # 列表

    # 注：创建一个 multiprocessing.Manager() 时，它会启动一个新的进程来管理这些被共享的对象
    manager = multiprocessing.Manager()
    # 获取 multiprocessing.Manager() 启动的进程的 id
    manager_pid = manager._process.pid
    print("Manager process ID:", manager_pid)
    # 杀掉 multiprocessing.Manager() 启动的进程
    manager.shutdown()
    
    lock = multiprocessing.Lock()
    p_list = [multiprocessing.Process(target=func2, args=(i,lock,v_i,v_d,v_c_char_p,m_dict,m_list)) for i in range(10)]
    for p in p_list:
        p.start()
    for p in p_list:
        p.join()

    print('sample2 ok', v_i.value, v_d.value, v_c_char_p.value, m_dict["k"], m_list)


if __name__ == '__main__':
    sample1()
    sample2()

standardLib/process_communication.py

# 本例用于演示如何在 python 的多进程中做数据通信

import os, time
import multiprocessing
import multiprocessing.connection
import queue
 
# 子进程的示例（继承自 multiprocessing.Process）
class MyChildProcess1(multiprocessing.Process):
    def __init__(self, conn):
        multiprocessing.Process.__init__(self)
        self.conn = conn
 
    def run(self):
        try:
            # poll() 阻塞，直到可以确定连接对象中是否有数据可以读取
            #   None 代表永不超时；如果指定一个数字则代表最大阻塞秒数
            while self.conn.poll(None):
                # 接收另一个连接发来的数据
                data = self.conn.recv()
                print(f'child recv:{data}')
                time.sleep(0.1)
                # 发送数据给另一个连接
                self.conn.send(data.upper())
        except EOFError:
            print("EOFError")

# 通过管道的方式，即 multiprocessing.Pipe() 实现进程间通信的示例
def sample1():
    # 实例化一个 multiprocessing.Pipe() 并返回一对连接，用于通信
    # 子进程用 conn1
    # 主进程用 conn2
    conn1, conn2 = multiprocessing.Pipe()
    p1 = MyChildProcess1(conn1) # 在 MyChildProcess1() 的 __init__() 中通过 multiprocessing.Process() 启动新的进程
    p1.daemon = True
    p1.start()
    for data in ['a', 'b', 'c', 'd']:
        # conn2 发数据给 conn1
        conn2.send(data)
        # conn2 接收 conn1 发来的数据
        recv_data = conn2.recv()
        print(f'main recv:{recv_data}')

    time.sleep(2)

    # 关闭连接
    conn1.close()
    conn2.close()

    p1.join()



# 子进程的示例（继承自 multiprocessing.Process）
class MyChildProcess2(multiprocessing.Process):
    # 注：主进程的发送队列就是子进程的接收队列，主进程的接收队列就是子进程的发送队列
    def __init__(self, recv_queue, send_queue):
        multiprocessing.Process.__init__(self)
        self.recv_queue = recv_queue
        self.send_queue = send_queue
 
    def run(self):
        try:
            while True:
                # 从队列中读取数据（阻塞，并指定超时时间为 2 秒。超时时间为 None 则永不超时）
                data = self.recv_queue.get(block=True, timeout=2)
                print(f'子进程 {os.getpid()} recv:{data}')
                time.sleep(0.1)
                # 把数据放入队列
                self.send_queue.put(data.upper())
        except queue.Empty:
            print(f'子进程 {os.getpid()} 超过 2 秒未收到数据')
    
# 通过队列的方式，即 multiprocessing.Queue() 实现进程间通信的示例
def sample2():
    # 创建发送队列和接收队列
    # 另外，如果想判断队列中的任务是否执行完毕的话可以使用 multiprocessing.JoinableQueue([maxsize])，它增加了 join() 和 task_done()
    #   比如，主进程向一个 queue 放入了多条数据，然后调用 queue.join() 阻塞，子进程从 queue 中每处理一条数据就调用一次 queue.task_done()，这样数据都处理完成后 queue.join() 就会停止阻塞
    send_queue = multiprocessing.Queue()
    recv_queue = multiprocessing.Queue()
    # 队列可以交给多个进程处理，自带并发处理逻辑，不用担心多个进程同时接收或发送的问题
    p1 = MyChildProcess2(send_queue, recv_queue) # 在 MyChildProcess2() 的 __init__() 中通过 multiprocessing.Process() 启动新的进程
    p2 = MyChildProcess2(send_queue, recv_queue) # 在 MyChildProcess2() 的 __init__() 中通过 multiprocessing.Process() 启动新的进程
    p1.daemon = True
    p2.daemon = True
    p1.start()
    p2.start()
    for data in ['a', 'b', 'c', 'd']:
        # 把数据放入队列
        send_queue.put(data)
        # 从队列中读取数据
        recv_data = recv_queue.get()
        print(f'main recv():{recv_data}')

    time.sleep(3)
    
    # 关闭队列
    send_queue.close()
    recv_queue.close()
    
    # 强制杀死指定的进程
    # p1.kill()
    # p2.kill()

    # 阻塞并等待指定的进程执行完毕
    p1.join()
    p2.join()


if __name__ == '__main__':
    sample1()
    sample2()
    

速战速决 Python https://github.com/webabcd/PythonSample
作者 webabcd