玩转python进程使用，知识点讲解与代码演示

红太狼 2021-12-14 22:25 223阅读 0赞

### 1.进程与线程的区别？ ###

**1.1形象来区分**

*  进程，能够完成多任务，比如 在一台电脑上能够同时运行多个QQ
 *  线程，能够完成多任务，比如 一个QQ中的多个聊天窗口

**1.2.原理区分**

1.  **进程是系统进行资源分配和调度的一个独立单位，所谓的进程就是“运行的程序+需要的资源”**
2.  **线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.**

**1.3两者之间的关系**

*  一个程序至少有一个进程,一个进程至少有一个线程.
 *  线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。
 *  进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率
 *  线线程不能够独立执行，必须依存在进程中

## 2.python中进程的实现 ##

python中的multiprocessing模块就是跨平台版本的多进程模块，提供了一个Process类来代表一个进程对象，这个对象可以理解为是一个独立的进程，可以执行另外的事情

**2.1python中多进程或多线程实现多任务模式**

**尖叫提示：如果是在window下执行多线程代码，必须要将实际执行的代码封装到if \_\_name\_\_ == "\_\_main\_\_":中去执行 ，不然肯定会报错，具体原因可以参考我的博客：**[https://blog.csdn.net/qq\_26442553/article/details/94595715][https_blog.csdn.net_qq_26442553_article_details_94595715]

import threading
    import time
    import multiprocessing
    
    def test1():
        while True:
            print("1--------")
            time.sleep(1)
    
    def test2():
        while True:
            print("2--------")
            time.sleep(1)
    def main():
     #    t1 = threading.Thread(target=test1)
     #    t2 = threading.Thread(target=test2)
     #    t1.start()
     #    t2.start()
    
        p1 = multiprocessing.Process(target=test1)  #用法和多线程差不多
        p2 = multiprocessing.Process(target=test2)
        p1.start()
        p2.start()
    #创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动
    
    if __name__ == "__main__":
        main()
    '''
    1--------
    2--------
    1--------
    2--------
    1--------
    2--------
    1--------
    2--------
    '''

**2.2Process类的常见方法介绍**

Process(\[group \[, target \[, name \[, args \[, kwargs\]\]\]\]\])

*  target：如果传递了函数的引用，可以任务这个子进程就执行这里的代码
 *  args：给target指定的函数传递的参数，以元组的方式传递
 *  kwargs：给target指定的函数传递命名参数
 *  name：给进程设定一个名字，可以不设定
 *  group：指定进程组，大多数情况下用不到

Process创建的实例对象的常用方法：

*  start()：启动子进程实例（创建子进程）
 *  is\_alive()：判断进程子进程是否还在活着
 *  join(\[timeout\])：是否等待子进程执行结束，或等待多少秒
 *  terminate()：不管任务是否完成，立即终止子进程

Process创建的实例对象的常用属性：

*  name：当前进程的别名，默认为Process-N，N为从1开始递增的整数
 *  pid：当前进程的pid（进程号）

import time
    
    def test(a, b, c, *args, **kwargs):
        print(a)
        print(b)
        print(c)
        print(args)
        print(kwargs)
    
    def main():
        print("----in 主进程 pid=%d---父进程pid=%d----" % (os.getpid(), os.getppid()))  #显示进程号
        p = multiprocessing.Process(target=test, args=(11, 22, 33, 44, 55, 66, 77, 88), kwargs={"mm":11})
        p.start()
    
    if __name__ == "__main__":
        main()
    '''
    ----in 主进程 pid=9796---父进程pid=15924----
    11
    22
    33
    (44, 55, 66, 77, 88)
    {'mm': 11}
    '''

**2.3进程间不共享全局变量，区别于线程**

import multiprocessing
    import os
    import time
    
    nums = [11, 22, 33]  #这里是可变对象的全局变量，所以在函数中修改其值时不用global声明
    
    def test():
        for i in range(33,36):
            nums.append(i)
            print("在进程中1中nums=%s" % str(nums))
            time.sleep(3)
    
    def test2():
        print("在进程中2中nums=%s" % str(nums))
    
    def main():
        print("----in 主进程 pid=%d---父进程pid=%d----" % (os.getpid(), os.getppid()))
        p1 = multiprocessing.Process(target=test)
        p1.start()
    
        # time.sleep(1)
        p1.join() #保证让p1执行完，再执行p2
    
        p2 = multiprocessing.Process(target=test2)
        p2.start()
    
    if __name__ == "__main__":
        main()
    '''结果显示，p1虽然执行完了，但是p2还是修改前的值。
    
    ----in 主进程 pid=12292---父进程pid=15924----
    在进程中1中nums=[11, 22, 33, 33]
    在进程中1中nums=[11, 22, 33, 33, 34]
    在进程中1中nums=[11, 22, 33, 33, 34, 35]
    在进程中2中nums=[11, 22, 33]'''

### 3.进程间的通信实现 ###

**      Process之间有时需要通信,python中使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序。**

**1.初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）；**

**2.如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；**

**3.如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；**

*  Queue.get\_nowait()：相当Queue.get(False)；
 *  Queue.put(item,\[block\[, timeout\]\])：将item消息写入队列，block默认值为True；

**4.如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出"Queue.Full"异常；**

**5.如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；**

*  Queue.put\_nowait(item)：相当Queue.put(item, False)；

from multiprocessing import Queue
    
    q=Queue(3) #初始化一个Queue对象，里面的数字表示最大接受消息数量
    q.put("消息1") 
    q.put("消息2")
    #Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；
    print(q.get()) #消息1,因为对列是先入先出。 
    q.put("消息1") 
    print(q.full())  # False Queue.full()：如果队列满了，返回True,反之False；
    q.put("消息3")
    print(q.full()) #True
    print(q.empty()) #False Queue.empty()：如果队列为空，返回True，反之False ；
    
    #因为消息列队已满下面的try都会抛出异常，第一个try会等待2秒后再抛出异常，第二个Try会立刻抛出异常
    try:
        q.put("消息4",True,2)
    except:
        print("消息列队已满，现有消息数量:%s"%q.qsize())  #Queue.qsize()：返回当前队列包含的消息数量；
    
    try:
        q.put_nowait("消息4")
    except:
        print("消息列队已满，现有消息数量:%s"%q.qsize())
    
    #推荐的方式，先判断消息列队是否已满，再写入
    if not q.full():
        q.put_nowait("消息4")
    
    #读取消息时，先判断消息列队是否为空，再读取
    if not q.empty():
        for i in range(q.qsize()):
            print(q.get_nowait())
    '''
    消息1
    False
    True
    消息列队已满，现有消息数量:3
    消息列队已满，现有消息数量:3
    消息2
    消息1
    消息3
    '''

统一声明：关于原创博客内容，可能会有部分内容参考自互联网，如有原创链接会声明引用；如找不到原创链接，在此声明如有侵权请联系删除哈。关于转载博客，如有原创链接会声明；如找不到原创链接，在此声明如有侵权请联系删除哈。

[https_blog.csdn.net_qq_26442553_article_details_94595715]: https://blog.csdn.net/qq_26442553/article/details/94595715