38并发编程

Posted 2021-02-27 jingpeng

一、多道技术

1.1、必备知识点

　　并发：看起来像同时运行的就可以称之为并发

　　并行：真正意义上的同时执行

 

注：并行肯定算，单核的计算机肯定不能实现并行，但是可以实现并发！！！

补充：我们直接假设单核就是一个核，干活的就一个人，不要考虑cpu里面的内核数

1.2、多道技术

　　节省多个程序运行的总耗时

1.2.1、空间上的复用

　　多个程序使用一台计算机

1.2.2、时间上的复用

　　一边执行程序一边写代码

1.2.3、切换与保存

　　CPU切换分为两种：

　　　　1.当一个程序遇到IO操作的时候，操作系统会剥夺该程序的CPU执行权限

　　　　　　作用：提高CPU的利用率，也不影响程序的执行效率

　　　　2.当一个程序长时间占用CPU的时候，操作系统也会剥夺该程序的CPU执行权限

　　　　　　弊端：降低了程序的执行效率

二、进程理论

2.1、进程与程序的区别

　　程序是已经编写好的代码，还未执行

　　进程是正在执行的程序

2.2、进程调度

2.2.1、先来先服务调度算法

　　先到的先执行，执行完毕后，进入下一个作业，对长作业有利，对短作业无益

2.2.2、短作业优先算法

　　最短的作业优先进行作业，执行完毕后，进入下一个作业

2.2.3、时间片轮转法+多级反馈队列

三、程序运行的三种状态

四、同步与异步

　　同步：任务提交之后，原地等待任务，等待过程中不做任何事

　　　　　程序层面上的表现是卡住了

　　异步：任务提交之后，不会原地等待任务，直接处理其他事情

　　　　　需要异步回调机制返回任务，之后执行

五、阻塞与非阻塞

　　阻塞：阻塞态

　　非阻塞：就绪态，运行态

最高效的组合就是异步非阻塞

六、开启代码进程的两种方式

　　建立一个启动项，启动项为主进程

　　　　第一种是：根据函数建立，启动项需要给函数传参，之后使用start启动

　　　　第二种是：根据类建立，启动类，之后使用start启动

注：

　　创建进程就是在内存中申请一块内存空间将需要运行的代码丢进去
　　一个进程对应在内存中就是一块独立的内存空间
　　多个进程对应在内存中就是多块独立的内存空间
　　进程与进程之间数据默认情况下是无法直接交互,如果想交互可以借助于第三方工具、模块

from multiprocessing import Process
import time


def task(name):
    print(‘%s is running‘%name)
    time.sleep(3)
    print(‘%s is over‘%name)


if __name__ == ‘__main__‘:
    # 1 创建一个对象
    p = Process(target=task, args=(‘jason‘,))
    # 容器类型哪怕里面只有1个元素 建议要用逗号隔开
    # 2 开启进程
    p.start()  # 告诉操作系统帮你创建一个进程  异步
    print(‘主‘)
    
    
# 第二种方式 类的继承
from multiprocessing import Process
import time


class MyProcess(Process):
    def run(self):
        print(‘hello bf girl‘)
        time.sleep(1)
        print(‘get out!‘)


if __name__ == ‘__main__‘:
    p = MyProcess()
    p.start()
    print(‘主‘)

七、join方法

　　join就是让主进程等待子进程代码执行完之后，再继续执行，不影响其他子进程的执行

from multiprocessing import Process
import time


def task(name, n):
    print(‘%s is running‘%name)
    time.sleep(n)
    print(‘%s is over‘%name)


if __name__ == ‘__main__‘:
    # p1 = Process(target=task, args=(‘jason‘, 1))
    # p2 = Process(target=task, args=(‘egon‘, 2))
    # p3 = Process(target=task, args=(‘tank‘, 3))
    # start_time = time.time()
    # p1.start()
    # p2.start()
    # p3.start()  # 仅仅是告诉操作系统要创建进程
    # # time.sleep(50000000000000000000)
    # # p.join()  # 主进程等待子进程p运行结束之后再继续往后执行
    # p1.join()
    # p2.join()
    # p3.join()
    start_time = time.time()
    p_list = []
    for i in range(1, 4):
        p = Process(target=task, args=(‘子进程%s‘%i, i))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print(‘主‘, time.time() - start_time)

八、进程之间数据的相互隔离

　　每个进程都有各自的名称空间，不会影响对方

from multiprocessing import Process


money = 100


def task():
    global money  # 局部修改全局
    money = 666
    print(‘子‘,money)


if __name__ == ‘__main__‘:
    p = Process(target=task)
    p.start()
    p.join()
    print(money)