python进程

world_in_world
已于 2024-04-06 17:03:15 修改
阅读量68
点赞数
分类专栏： python基础文章标签： python
于 2023-03-12 20:47:07 首次发布
本文链接：https://blog.csdn.net/world_in_world/article/details/129480749
版权
python基础专栏收录该内容
11 篇文章 0 订阅
订阅专栏

"""
一、进程的操作与线程大体相同。
二、线程是通过进程来创建的，那么在运行一个python文件的时候，首先操作系统会自动创建一个主进程，然后通过python代码在这个主进程中创建线程。
三、在不同的操作系统上，进程的创建方式是不一样的，所以当通过进程来实现多任务时，必须实现一个函数路口，否则会报错。
    Windows创建进程的方式：spawn接口
    MacOs创建进程的方式：fork接口
    Linu创建进程的方式：fork接口
四、开启两个进程，复制两份代码，每个进程只运行一份代码中的某个任务的代码。
"""
# import time
# import multiprocessing
#
# def test_1():
#     for i in range(5):
#         print('这是任务1：', i)
#         time.sleep(1)
#
# def test_2():
#     for i in range(5):
#         print('这是任务1：', i)
#         time.sleep(1)
#
# def main():
#     # multiprocessing.set_start_method('spawn')  # 在创建进程对象之前，就需要手动指定创建进程的方式
#     p1 = multiprocessing.Process(target=test_1)
#     p2 = multiprocessing.Process(target=test_2)
#     p1.start()
#     p2.start()
#
# # main()
# if __name__ == '__main__':  # 不实现会报错（对于进程的创建，函数路口可以判断当前系统类型，并根据当前系统类型去调用对应的api来创建进程）
#     main()



"""
主进程与子进程
"""
# import time
# import multiprocessing
#
# def run():
#     # 子进程要执行的代码
#     while True:
#         print('当前任务子进程运行中')
#         time.sleep(1)
#
# if __name__ == '__main__':  # 创建主进程
#     p = multiprocessing.Process(target=run)
#     p.start()  # 启动子进程对象，并创建子进程，同时解释器自动调用run方法以运行子进程任务
#     while True:
#         print('当前任务主进程运行中')
#         time.sleep(1)



"""
获取进程的pid（操作系统在创建进程的时候，会给进程编号即pid）
"""
# import os
# import multiprocessing
#
# def run():
#     print('子进程pid=%d运行中' % os.getpid())  # os.getpid()获取当前进程号
#
# if __name__ == '__main__':
#     print('主进程pid=%d' % os.getpid())
#     p = multiprocessing.Process(target=run)
#     p.start()


# import os
# import time
# import multiprocessing
# def run():
#     print(f'当前子进程pid={os.getpid()}，当前子进程的父进程pid={os.getppid()}')  # os.getppid()获取当前进程的父进程的进程号
#     time.sleep(1)
#
# def main():
#     print(f'当前py文件的主进程pid={os.getpid()}，运行当前py文件的进程pid={os.getppid()}')
#     p = multiprocessing.Process(target=run)
#     p.start()
#
# if __name__ == '__main__':
#     main()



"""
进程的运行顺序是无序的（在Windows系统中，当任务量很少时，才看起来是顺序运行）
"""
# import time
# import multiprocessing
#
# def test_1():
#     for i in range(10):
#         print('这是任务1：', i)
#         time.sleep(1)
#
# def test_2():
#     for i in range(10):
#         print('这是任务2：', i)
#         time.sleep(1)
#
# if __name__ == '__main__':
#     p1 = multiprocessing.Process(target=test_1)
#     p2 = multiprocessing.Process(target=test_2)
#     p1.start()
#     p2.start()



"""
一、给子进程指定的函数传递参数
二、僵尸进程：（Linux、MacOs系统）
    0、在每个进程退出的时候,内核会释放该进程所有的资源,包括打开的文件、占用的内存等,但是仍然为其保留一定的信息(包括进程号the process ID,
      退出状态the termination status of the process,运行时间the amount of CPU time taken by the process等),
      直到父进程通过调用wait / waitpid函数来获取这些信息时才释放，而未调用之前该进程便成为僵尸进程。
    1、什么是僵尸进程?
        UNIX 系统中,一个进程结束了,而其父进程还没有结束,并且其父进程没有等待(调用wait / waitpid)他，那么他将变成一个僵尸进程。
        如果该进程的父进程已经先结束了,那么该进程就不会变成僵尸进程，因为每个进程结束的时候，系统都会扫描当前系统中所运行的所有进程,
        看有没有哪个进程是刚刚结束的这个进程的子进程,如果有的话,就由Init来接管他,成为他的父进程,从而保证每个进程都会有一个父进程。
        而Init进程会自动wait其子进程,因此被Init接管的所有进程都不会变成僵尸进程。
    2、子进程结束后为什么要进入僵尸状态?
        因为父进程可能要取得子进程的退出状态等信息。
    3、僵尸状态是每个子进程必经过的状态吗？
        是的。任何一个子进程(init除外)在exit()之后，并非马上就会消失掉，而是留下一个称为僵尸进程(Zombie)的数据结构，等待父进程处理。
        这是每个子进程在结束时都要经过的阶段。如果子进程在exit()之后，父进程没有来得及处理，这时用ps命令就能看到子进程的状态是“Z”。
        如果父进程能及时处理，可能用ps命令就来不及看到子进程的僵尸状态，但这并不等于子进程不经过僵尸状态。
        如果父进程在子进程结束之前退出，则子进程将由init接管。init将会以父进程的身份对僵尸状态的子进程进行处理。
    4、如何查看僵尸进程？
        $ ps -el    其中，有标记为Z的进程就是僵尸进程。
        S代表休眠状态；D代表不可中断的休眠状态；R代表运行状态；Z代表僵尸状态；T代表停止或跟踪状态。
    5、如何避免僵尸进程？
        1）父进程通过调用wait或waitpid等函数等待子进程结束，这会导致父进程挂起
        2）如果父进程很忙，那么可以用signal函数为SIGCHLD安装handler，因为子进程结束后，父进程会收到该信号，可以在handler中调用wait回收
        3）如果父进程不关心子进程什么时候结束，那么可以用signal（SIGCHLD, SIG_IGN）通知内核，自己对子进程的结束不感兴趣，那么子进程结束后，内核会回收，并且不再给父进程发送信号
        4）还有一些技巧，就是fork两次，父进程fork一个子进程，然后继续工作，子进程fork一个孙进程后退出，那么孙进程被init接管，孙进程结束后，init会回收。不过子进程的回收还要自己做。
"""
# import multiprocessing
#
# def run(a, b, c, *args, **kwargs):
#     print(a, b, c)
#     print(args)
#     print(kwargs)
#
# if __name__ == '__main__':
#     p = multiprocessing.Process(target=run, args=('大哥', 18, '男', '逗逼'), kwargs={'地址': '安徽'})
#     p.start()


# import time
# import os
# import multiprocessing
#
# def run(name, age, *args, **kwargs):
#     for i in range(10):
#         print('子进程运行中……，name=%s，age=%d，pid=%d' % (name, age, os.getpid()))
#         print(args, kwargs)
#         time.sleep(0.2)
#
# if __name__ == '__main__':
#     p = multiprocessing.Process(target=run, args=('没头脑', 18, '大哥', '小弟'), kwargs={'ProcessId': 1111})
#     p.start()
#     time.sleep(1)
#     p.terminate()  # terminate()：不管进程任务是否完成，立即终止进程。此时直接调用terminate方法，会使停止的进程变成了一个僵尸进程，只能等待主进程结束，这个僵尸进程才会消失
#     # p.join()  # join([timeout])：等待子进程终止，或等待timeout秒。此处等待子进程真正运行结束
#     print(p.is_alive())  # is_alive()：判断进程是否存在



"""
进程与进程之间是相互独立的，不能进行资源的共享
"""
# import multiprocessing
#
# nums = [1, 2, 3]
#
# def test_1():
#     nums.append(4)
#     print(f'在子进程1中nums的值为：', nums)
#
# def test_2():
#     nums.append(5)
#     print(f'在子进程2中nums的值为：', nums)
#
# def main():
#     p1 = multiprocessing.Process(target=test_1)
#     p2 = multiprocessing.Process(target=test_2)
#     p1.start()
#     p1.join()  # 确保进程1运行完毕之后才运行进程2
#     p2.start()
#
# if __name__ == '__main__':
#     main()  # 三个进程三份代码，一个进程只运行一份代码中对应的任务



"""
使用队列完成进程间的数据通信
补充：
初始化Queue()对象时（例如：q = multiprocessing.Queue(maxsize=10)），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）；
- Queue.qsize()：返回当前队列包含的消息数量；
- Queue.empty()：如果队列为空，返回True，反之False ；
- Queue.full()：如果队列满了，返回True,反之False；
- Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True，timeout默认值为None；
    1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到消息列队腾出空间为止，
       如果设置了timeout，消息列队如果没有空间，则会阻塞timeout秒，若还没空间，则抛出"Queue.Full"异常（消息列队如果有空间，则不会等待，立即传入消息）；
    2）如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"queue.Full"异常；
- Queue.put_nowait(item)：相当Queue.put(item, block=False)；
- Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True，timeout默认值为None；
    1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，
       如果设置了timeout，消息列队如果没有消息，则会阻塞timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常（消息列队如果有消息，则不会等待，立即获取消息）；
    2）如果block值为False，消息列队如果为空，则会立刻抛出"_queue.Empty"异常；
- Queue.get_nowait()：相当Queue.get(False)；
- Queue.task_done()：调用put()计数+1，get()计数不会-1，get()需要和task_done()一起使用计数才会-1；
- Queue.join()：队列中维持了一个计数，计数不为0时阻塞线程，计数为0时才会继续往后执行.
"""
# import multiprocessing
#
# def spider_set_data(q):
#     data = [1, 2, 3, 4]
#     for _ in data:
#         q.put(_)  # 往队列中传入一条消息
#     print('消息传入队列成功')
#
# def get_data(q):
#     queue_data = list()
#     while True:
#         data = q.get()  # 从队列中获取一条消息，并将其移除
#         queue_data.append(data)
#         if q.empty():  # 判断队列是否为空，返回一个布尔值
#             break
#     print(queue_data)
#
# def main():
#     q = multiprocessing.Queue()  # 创建一个队列对象
#     p1 = multiprocessing.Process(target=spider_set_data, args=(q,))
#     p2 = multiprocessing.Process(target=get_data, args=(q,))
#     p1.start()
#     p1.join()
#     p2.start()
#
# if __name__ == '__main__':
#     main()



"""
进程池
multiprocessing.Pool常用函数解析：
- apply_async(func[, args[, kwds]])：使用非阻塞方式调用 func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），
    args是要传递给func的参数列表，kwds是要传递给func的关键字参数列表
- close()：关闭Pool，使其不再接受新的任务
- terminate()：不管任务是否完成，立即终止
- join()：阻塞主进程，等待子进程的退出，必须在close或terminate之后使用
"""
# import time
# import random
# import multiprocessing
#
# def worker(msg):
#     t_start = time.time()
#     time.sleep(random.random()*2)
#     t_end = time.time()
#     print(msg, '任务耗时：%.2f' % (t_end-t_start))
#
# def main():
#     po = multiprocessing.Pool(3)  # 创建进程池对象（进程池对象创建好的同时，系统也创建好了3个进程对象，但还没启动进程，自然也没绑定任务）
#     for i in range(10):
#         po.apply_async(worker, (i,))
#     print('进程池启动')
#     po.close()  # 关闭进程池，关闭后进程池不再接收新的任务，此时close方法只是关闭了进程池的路口，进程池资源还没有被释放，只有进程池任务全部执行完毕之后，进程池才会释放资源
#     po.join()
#     print('任务结束')
#
# if __name__ == '__main__':
#     main()



"""
进程池中的队列：如果要在进程池中运用队列，就需要使用multiprocessing.Manager()中的Queue()来创建队列，而不是multiprocessing.Queue()，否则会报错
"""
from multiprocessing import Manager, Pool
import os
import time

def reader(q):
    print("reader启动进程(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
    for i in range(q.qsize()):
        print("reader从Queue获取到消息：%s" % q.get())

def writer(q):
    print("writer启动进程(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
    for i in "tuling":
        q.put(i)

if __name__ == "__main__":
    print("进程(%s) start" % os.getpid())
    q = Manager().Queue()  # 使用Manager中的Queue
    po = Pool()
    po.apply_async(writer, (q,))
    time.sleep(0.1)
    po.apply_async(reader, (q,))
    po.close()
    po.join()
    print("进程(%s) End" % os.getpid())