程序和进程，PID，创建进程-multiprocessing模块的Process类， Pool 类，Queue类（多任务-多进程）

程序和进程

1.程序是安装在计算机硬盘中的，运行的程序就叫进程，计算机会为正在运行的程序分配空间

2.进程标识符PID（Process ID）
定义：PID是操作系统中用于唯一标识一个进程的数字。每个进程在创建时都会被分配一个独一无二的PID，用于区分不同的进程。
获取进程的pid用os模块中的getpid（）获取自己进程的标识符。getppid（）获取父进程的标识符

3.在windows操作系统中创建进程：

当进程数量较少时候，使用在模块multiprocessing模块的process类，参数中target’必须写

需要注意args需要传递的位置参数如果只有一个，因为是元组也需要加， ，例如args=（18，）

对于主进程和子进程的进行：
例如对于在main程序中调用函数开始子进程的运行时，
主进程并不停止执行：当主进程中的某个Process对象的start()方法被调用时，主进程并不会停止执行。相反，主进程会继续执行其后续的代码，同时操作系统会并行地启动一个新的子进程来执行Process对象指定的任务。
并行执行：主进程和子进程是并行运行的。这意味着它们可以同时执行，而不是一个等待另一个完成。主进程可以继续执行其后续的代码，而子进程则开始执行其指定的任务。
等待子进程完成： 如果你希望主进程等待子进程完成后再继续执行，你可以使用Process对象的 join()方法。调用join()方法会阻塞主进程，直到对应的子进程执行完毕。

from multiprocessing import Process  
import time  
  
def worker():  
    """子进程执行的函数"""  
    print('子进程开始执行')  
    time.sleep(2)  # 模拟耗时操作  
    print('子进程执行完毕')  
  
if __name__ == '__main__':  
	print('主进程开始执行')
    p = Process(target=worker)  
    p.start()  # 启动子进程  
    print('主进程继续执行')  
    p.join()  # 等待子进程完成  
    print('主进程等待子进程完成后继续执行')
#主进程开始执行
#主进程继续执行
#子进程开始执行
#子进程执行完毕
#主进程等待子进程完成后继续执行

4.Process类中的方法和属性

5.继承式创建子进程

当进程数量较多时候，使用在模块multiprocessing模块的pool池


apply()阻塞式执行例子

from multiprocessing import Pool  
import time  
  
def square(x):  
    time.sleep(1)  # 模拟耗时的操作  
    return x * x  
  
if __name__ == '__main__':  
    with Pool(processes=4) as pool:  
        # 使用apply()执行，这是阻塞的  
        result1 = pool.apply(square, (2,))  
        print(f"Result 1: {result1}")  
  
        # 再次调用apply()，这也会阻塞  
        result2 = pool.apply(square, (3,))  
        print(f"Result 2: {result2}")  
  
    # 注意：只有当上面的apply()调用完成后，程序才会继续执行到这里

apply_async()方法是非阻塞的，它立即返回一个AsyncResult对象，你可以使用这个对象来查询任务的状态或等待任务完成。

from multiprocessing import Pool  
import time  
  
def square(x):  
    time.sleep(1)  # 模拟耗时的操作  
    return x * x  
  
if __name__ == '__main__':  
    with Pool(processes=4) as pool:  
        # 使用apply_async()执行，这是非阻塞的  
        result1 = pool.apply_async(square, (2,))  
        result2 = pool.apply_async(square, (3,))  
  
        # 你可以在这里执行其他任务，而不需要等待square(2)和square(3)完成  
  
        # 如果你需要结果，可以使用get()方法，但请注意，get()是阻塞的  
        print(f"Result 1: {result1.get()}")  # 这会等待square(2)完成  
        print(f"Result 2: {result2.get()}")  # 这会等待square(3)完成  
  
    # 注意：只有当上面的get()调用完成后，程序才会继续执行到这里

进程之间数据是不共享的，每个进程都有自己独立的内存空间，这意味着在默认情况下，一个进程不能直接访问或修改另一个进程的数据。然而，Python提供了几种机制来实现进程间的数据共享和通信。
使用multiprocessing模块中的Queue

Queue： 是进程安全的队列，用于在多进程间安全地传递消息。可以通过队列来共享数据，主进程将数据放入队列，子进程从队列中取出数据进行处理。

一个简单的出队入队示例：

if __name__ == '__main__':
    q=Queue(3)
    print('full?',q.full())
    print('empty?',q.empty())
    q.put('data1')
    q.put('data2')
    print('full?', q.full())
    print('empty?', q.empty())

    print(q.get())
    print('size of q',q.qsize())

put(item, block=True, timeout=None)和put_nowait(item)的区别：

1. put() 方法在队列满时可以等待空间变得可用（可选地，可以指定一个超时时间，timeout：当 block 为 True 时，这个参数指定了等待的最大秒数。如果在这段时间内队列没有变得可用，将抛出一个 Full 异常。block：如果队列已满，此参数控制 put() 方法是等待空间变得可用（True，默认值），还是立即抛出异常（False）。），而 put_nowait() 或 putnowait() 方法在队列满时会 立即抛出一个异常。
   例如：q.put(‘data4’,timeout=2)大小为3的队列里放第四个，表示等两秒没空位就抛异常
2. 使用 put() 时，可以通过设置 block=False 来获得与 put_nowait() 或 putnowait() 相似的行为，但 put_nowait() 或 putnowait() 在语法上更简洁明了。
3. 在需要非阻塞行为的场景中（即，你不希望线程在尝试向队列添加项目时被阻塞），应该使用 put_nowait() 或 putnowait()。否则，put() 方法提供了更多的灵活性和控制。

如何通过 Queue来是实现进程通信？

使用Queue和Process实现进程通信

例子：
Queue: 使用multiprocessing.Queue()创建了一个进程安全的队列。生产者可以向队列中发送数据，而消费者可以从队列中接收数据。
Producer: 生产者函数producer通过queue.put(i)向队列中发送数据。这里使用了一个简单的循环来模拟发送数据的过程，并通过time.sleep(1)来模拟耗时操作。
Consumer: 消费者函数consumer通过queue.get()从队列中接收数据。由于get()方法是阻塞的，如果队列为空，消费者进程将等待直到队列中有数据可接收。我们使用None作为结束信号，当消费者接收到None时，它将退出循环。
主程序: 主程序首先创建了一个队列和两个进程（一个生产者和一个消费者）。然后启动这两个进程，等待生产者完成其工作，并通过向队列发送None来通知消费者结束。最后，主程序等待消费者完成。

import multiprocessing  
import time  
  
def producer(queue):  
    """ 生产者进程，向队列中发送数据 """  
    for i in range(5):  
        print(f'Producer: Sending {i}')  
        queue.put(i)  
        time.sleep(1)  # 模拟耗时操作  
  
def consumer(queue):  
    """ 消费者进程，从队列中接收数据 """  
    while True:  
        item = queue.get()  # 阻塞，直到队列中有数据  
        if item is None:  # 使用None作为结束信号  
            break  
        print(f'Consumer: Received {item}')  
        queue.task_done()  # 表示前一个任务已经处理完毕  
  
if __name__ == '__main__':  
    # 创建一个队列  
    q = multiprocessing.Queue()  
  
    # 创建生产者和消费者进程  
    p1 = multiprocessing.Process(target=producer, args=(q,))  
    p2 = multiprocessing.Process(target=consumer, args=(q,))  
  
    # 启动进程  
    p1.start()  
    p2.start()  
  
    # 等待生产者完成  
    p1.join()  
  
    # 发送结束信号给消费者  
    q.put(None)  
  
    # 等待消费者完成  
    p2.join()