多任务--进程

落日映苍穹つ 2022-04-23 08:42 182阅读 0赞

### 程序以及状态 ###

程序：如\*\*\*.exe文件这种就是一个程序，是静态的

进程：一个程序运行起来之后，代码+用到的资源称之为进程，它是操作系统分配资源的基本单元

简单来说，程序运行起来就是进程，程序只有一个但是同一程序可能会有很多的进程，例如QQ的代码只有一份，用户可以打开很多的QQ界面。不仅可以通过线程完成多任务，进程也是可以的。

使用进程实现多任务，示例代码：

1 import time
      2 import multiprocessing
      3 
      4 
      5 def test1():
      6     while True:
      7         print("---1---")
      8         time.sleep(1)
      9 
     10 
     11 def test2():
     12     while True:
     13         print('---2---')
     14         time.sleep(1)
     15 
     16 def main():
     17     t1 = multiprocessing.Process(target=test1)
     18     t1.start()
     19     t2 = multiprocessing.Process(target=test2)
     20     t2.start()
     21 
     22 if __name__=='__main__':
     23     main()

上面这段代码和之前线程那一块代码基本是一样的，无非就是将原来的Thread变成了Process这个类，运行结果和线程没什么区别。

### 进程查看自己的进程号 ###

在线程中可以通过threading.enumerate()查看当前代码中有多少个线程。在进程中如何查看自己的当前有多少个进程？

示例代码：

1 import time
      2 import multiprocessing
      3 import os
      4 
      5 
      6 def test1():
      7     for i in range(3):
      8         print('----1----')
      9         time.sleep(1)
     10     print('zi process pid is %d'%(os.getpid()))  # 查看子进程号
     11 
     12 
     13 def test2():
     14     for i in range(3):
     15         print('----2----')
     16         time.sleep(1)
     17     print('zi process pid is %d'%(os.getpid()))
     18 
     19 
     20 def main():
     21     t1 = multiprocessing.Process(target=test1)
     22     t2 = multiprocessing.Process(target=test2)
     23     t1.start()
     24     t2.start()
     25     print('main process pid is %d'%(os.getpid()))  # 查看主进程号
     26 
     27 
     28 if __name__=='__main__':
     29     main()

Process语法结构如下：

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（进程号）

示例代码：

# -*- coding:utf-8 -*-
    from multiprocessing import Process
    import os
    from time import sleep
    
    
    def run_proc(name, age, **kwargs):
        for i in range(10):
            print('子进程运行中，name= %s,age=%d ,pid=%d...' % (name, age, os.getpid()))
            print(kwargs)
            sleep(0.2)
    
    if __name__=='__main__':
        # 创建对象时添加参数
        p = Process(target=run_proc, args=('test',18), kwargs={"m":20})
        p.start()
        sleep(1)  # 1秒中之后，立即结束子进程
        p.terminate()
        p.join()

### 进程之间不共享全局变量 ###

# -*- coding:utf-8 -*-
    from multiprocessing import Process
    import os
    import time
    
    nums = [11, 22]
    
    def work1():
        """子进程要执行的代码"""
        print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
        for i in range(3):
            nums.append(i)
            time.sleep(1)
            print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
    
    def work2():
        """子进程要执行的代码"""
        print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))
    
    if __name__ == '__main__':
        p1 = Process(target=work1)
        p1.start()
        p1.join()
    
        p2 = Process(target=work2)
        p2.start()
    
    
    输出结果：
    in process1 pid=11349 ,nums=[11, 22]
    in process1 pid=11349 ,nums=[11, 22, 0]
    in process1 pid=11349 ,nums=[11, 22, 0, 1]
    in process1 pid=11349 ,nums=[11, 22, 0, 1, 2]
    in process2 pid=11350 ,nums=[11, 22]

### 进程和线程的区别 ###

进程和线程都可以完成多任务，线程更加轻量级。进程是系统进行资源分配和调度的独立单位；线程是进程的一个实体，是CPU调度和分配的基本资源，它是比进程更小的能独立运行的基本单位。线程自己基本是不拥有系统资源，只拥有一点在运行中必不可少的资源。因此线程更加轻量级。

区别：一个程序至少有一个进程，一个进程至少有一个线程。线程的划分尺度小于进程，