Python测试开发预习课10/15

1、复习

进程：一个正在执行的程序

进程是操作系统分配资源的最小单位

一个进程至少有一个线程，当然也可以有多个线程

多个进程之间可以通讯，但是每个进程都保存在内存的
独立空间中，互相不能够访问对方线程内部的资源。

多进程：通过利用多核cpu，提升程序的并发执行能力。
Jmeter（多线程）loadrunner：多进程 多线程

多线程：都在一个进程中，节省资源的申请。多线程之间切换执行速度更快。（推荐）

多进程：需要更多的系统资源。多进程切换，cpu上下文切换，切换效率会更低。

Python 多进程、多线程、协程，他们有点缺点、应用场景。

多线程：并发能力很弱。python GIL锁（global interpreter lock），
将python限定为同步执行(不能并发)。
应用场景：多线程的时候无法利用多核cpu的计算能力，产生大量io等待的情况下。
不需要太多计算能力的场景的并发。
例如：、
大量本地io操作（本地文件）：读写本地文件
大量网络io操作（网络请求）：多线程下载网页、请求网络服务的接口

多进程：能用使用多核cpu进行并发计算。比多线程写起来更复杂一些。

协程：单线程执行，当遇到io等待的时候，或者其他的等待，它会自动切换任务执行。
看起来像多线程一样。
本质就充分提高了单线程的执行效率。

多进程+协程。

2、主进程与子进程

1）写一个函数：任务函数，写了一些代码（代表多进程需要执行的任务，可简单、可复杂）
2）实例化一个子进程对象，指定它要运行的任务函数，以及函数所有的参数。
3）启动这个进程对象(用start()方法)，进程就开始执行任务函数的内容。
4）通常要调用进程一个join()方法，等待刚才启动的子进程完全执行完毕后，在执行主进程。
主进程收到子进程执行完毕的通知后，则继续执行主进程。
注意：必须所有的进程都start完毕的情况下，才能执行join。

如果没有用join,则主进程可能会在子进程还在运行时就结束了。
用了join，则主进程一定会在子进程结束后才执行完毕。

生成多进程方式1：

import os,time
from multiprocessing import Process
 
def worker():#第一步：定义任务函数，打印了一下子进程的进程信息，开始和结束
    print("子进程执行中>>> pid={0},ppid={1}".format(\
os.getpid(),os.getppid()))#os.getpid():获取当前进程号     os.getppid()：获取当前进程的父进程号
    time.sleep(2)
    print("子进程终止>>> pid={0}".format(os.getpid()))
 
def main():
    print("主进程执行中>>> pid={0}".format(os.getpid())) #打印了主进程id
 
    ps=[]
    # 创建子进程实例
    for i in range(2):#第二步：创建了2个进程，绑定了任务函数，指定了函数参数
                      #给进程起了个名字
        p=Process(target=worker,name="worker"+str(i),args=())
        ps.append(p)#放到一个列表中，这个时候进程对象创建成功，未启动
 
    # 开启进程
    for i in range(2):
        ps[i].start()##第三步：通过遍历列表，启动所有的进程（start）
 
    # 阻塞进程
    for i in range(2):
        ps[i].join()#第四步：遍历，将所有的子进程执行join方法。
 
    print("主进程终止")#所有子进程执行完毕后，主进程才会执行这一句。
 
if __name__ == '__main__':
main()

模板字符串

>>> "I am a %s years old boy!"  %17
'I am a 17 years old boy!'
>>> "I am a {0} years old boy!".format(18)
'I am a 18 years old boy!'

需要并发执行的任务，放进子进程

其他都是主进程。

不写join，则主进程和子进程是同时执行的，但是谁先结束也不一定。

写了join，那么主进程必须等待子进程执行结束了，才能继续执行join后面的语句

生成多进程方式2：

import os,time
from multiprocessing import Process
 
class MyProcess(Process):#通过继承Process类，来生成子进程对象
    def __init__(self):
        Process.__init__(self) #执行了父类的构造方法
 
    def run(self):#run函数命名不能变，它就是任务函数
        print("子进程开始>>> pid={0},ppid={1}".format(os.getpid(),os.getppid()))
        time.sleep(2)
        print("子进程终止>>> pid={}".format(os.getpid()))
 
def main():
    print("主进程开始>>> pid={}".format(os.getpid())) #打印主进程号
    myp=MyProcess() #实例化
    myp.start()#启动
    myp.join() #join
    print("主进程终止")
 
if __name__ == '__main__':#当程序文件本身，被运行的时候，才会执行if下的代码。
                          #如果被import a导入的时候，这个if下的代码不执行
    main()

进程池

import os,time
from multiprocessing import Pool
 
def worker(arg):#任务函数
    print("子进程开始执行>>> pid={},ppid={},编号{}".format(os.getpid(),os.getppid(),arg))
    time.sleep(5.5)
    print("子进程终止>>> pid={},ppid={},编号{}".format(os.getpid(),os.getppid(),arg))
 
def main():
    print("主进程开始执行>>> pid={}".format(os.getpid()))
    ps=Pool(6) #生成了一个进程池对象，里面最多6个进程，也就是说最多并发6个子进程。
    for i in range(10):
        #ps.apply(worker,args=(i,))          # 同步执行，10个任务必须是一个完成了，
                                             #才能执行下一个
        ps.apply_async(worker,args=(i,))  # 异步执行，10个任务通知执行，
                                          #通过进程池来执行并发任务
                                          #进程池会自动找不同个数的进程来执行任务函数
 
    # 关闭进程池，停止接受其它进程，不加此句执行join会报错
    ps.close()#要写。
    # 阻塞进程
    ps.join()#所有进程池中的任务都执行完毕了，才能继续执行主进程。
    print("主进程终止")
 
if __name__ == '__main__':
main()

线程安全与线程不安全（多线程场景）

线程安全和不安全是完全针对多线程场景来说的，单线程都是安全的。

线程安全：操作一个数据的时候，不会产生竞争。

线程不安全：产生竞争，导致数据操作不对。

a=1
我启动两个线程，各有一个任务，给a+1。

期望的结果：a=3，线程1执行结束后a=2，线程2执行结束后a=3
线程1，先拿到a的值，这个时候1,1+1，赋值给了a，这个时候a=2
线程2，先拿到a的值，这个时候2,2+1，赋值给了a，这个时候a=3

有竞争的情况下：
线程1：先拿到a的值，这个时候1,1+1，（卡主了一下）赋值给了a，这个时候a=2
线程2：启动了，他拿到a的值，这个时候1,1+1（卡主了一下，线程1继续执行了），
赋值给了a，这个时候a=2
实际的结果a=2（线程不安全）
加锁

1 线程1：先给a加锁，先拿到a的值，这个时候1,1+1，（卡主了一下）
2 线程2：启动了，他去拿到a的值，结果发现有锁，取不到，只能等别人把锁释放了，才能去取。
目前只能死等。
3 线程1，不卡了，执行完毕了，a=2，释放锁，a=2
4 线程2：隔了一会儿，又去取a的值，这个时候发现没锁了，它加了一把锁，取a的值，a=2
2+1=3,a=3,释放锁。
线程安全的效率要比不安全的效率差很多。
vector：线程安全的，（多线程）
arraylist:线程不安全的，效率高呀，数据可能出错呀。（单线程）
线程安全通常都是加锁来实现同步。

加锁之后执行代码

import multiprocessing
import sys
import time
import random
#任务1：使用锁方法1 
def worker1(): #任务函数1
    
    for i in range(10):
        time.sleep(random.randint(1,5))
        print("task1")

#任务2：使用锁方式2      
def worker2( ):#任务函数2
    
    try:
        for i in range(10):
            time.sleep(random.randint(1,2))
            print("task2")

    finally:
        pass
 
if __name__ == "__main__":
 
    
  
    lock = multiprocessing.Lock()#实例化进程锁对象
    w = multiprocessing.Process(target=worker1, args=( ))#生成进程1
    nw = multiprocessing.Process(target=worker2, args=())#生成进程2
 
    w.start()
    nw.start()
 
    w.join()
nw.join()