CSIC_716_20191204【并发编程理论基础】

进程：正在执行的一个过程，进程是对正在执行过程的一个抽象。区别于程序，

进程的三种状态：  进程是动态的。

就绪态ready:   进程具备运行状态，等待操作系统分配处理器

运行状态running：进程正在占用处理器运行。  运行态的进程当遇到IO时，就会变成阻塞态，当超过时间片时，会变成就绪态

阻塞态blocked：进程不具备运行条件，正在等待某个事件的完成

 

python中开启多个进程的方法：

 

1、定义函数方式，开启新的子进程，但是没有回收子进程。此时，主进程和子进程是异步的。

from multiprocessing import Process
import time


def task(name):
    print(f'start..{name}..')
    time.sleep(3)
    print(f'end..{name}...')


if __name__ == '__main__':
    # Process()实例化的时候，args代表target所指函数中的参数，如果没有参数，就不需要args
    pro_obj = Process(target=task, args=('reax',))  # 定义元祖，如果只有一个元素，一定要加逗号
    pro_obj.start()
    print('start主进程')

　　

2、开启新的子进程，并回收子进程，此时，主进程一定会等子进程执行完成，进程回收之后 join( )，才提交执行主进程，此时主子进程是同步的。

def task(name):
    time.sleep(4)
    print(f'start..{name}..')
    time.sleep(3)
    print(f'end..{name}...')


if __name__ == '__main__':
    # Process()实例化的时候，args代表target所指函数中的参数，如果没有参数，就不需要args
    pro_obj = Process(target=task, args=('reax',))  # 定义元祖，如果只有一个元素，一定要加逗号
    pro_obj.start()
    pro_obj.join()
    print('start主进程')

　　

3、通过继承Process类实现。

from multiprocessing import Process
import time


class MyProcess(Process):
    def run(self):
        print(f'start...{self.name}的子进程')
        time.sleep(3)
        print(f'end...{self.name}的子进程')


if __name__ == '__main__':
    list1 = []

    for line in range(2):
        obj = MyProcess()
        obj.start()
        list1.append(obj)

    for obj in list1:
        obj.join()

    print('主进程...')

　　

 

多道技术：是针对一个CPU而言，

时间的复用：遇到IO或者时间占用过长

空间的复用：一个CPU可以提供给多个进程使用

 

并发：针对CPU的一个核，通过不停切换进程，实现伪并行。

并行：

 

 

 

 

 

 

 

 

 

 

标签：__,obj,name,start,716,print,CSIC,20191204,进程
来源： https://www.cnblogs.com/csic716/p/11997309.html