Python测试开发预习课9/24-多进程第二讲

1、复习

进程：

1）进程是可并发执行的程序在某个数据集合上的一次计算活动，
2）也是操作系统进行资源分配和调度的基本单位。

qq：启动一个qq，运行了一个进程。
启动第二个qq，又运行了一个进程。
是有2个进程同事运行的。

操作系统：
cpu
内存
硬盘

运行程序的，运行起来的程序就是进程。
进程运行的时候，必须要有资源，操作系统来分配资源。
操作会根据进程为单位进行分配。而不是以线程为单位

程序不是进程，只有程序属于运行状态时，才是进程。
程序是一个或这个多个文件，存储在硬盘上。

ps 进程信息

进程是由程序、数据和进程控制块（存储很多进程的相关信息PCB
比如说：父进程号，本身的进程号。。。。。
）三部分组成的。

进程的特征：
动态性：进程有生命周期。
并发性：多个进程可同存于内存中
独立性：资源分配和调度的基本单位。
进程间通讯：两个程序之间进行交互
制约性：并发进程间存在制约关系
结构特征：进程由程序块 、数据块、进程控制块三部分组成。

TCP UDP
有什么区别
适合什么场景
各有什么优缺点？

同步和异步
应用场景

进程的状态

创建—》就绪（准备好了，还没有运行）—》运行—》阻塞—》结束

创建：操作系统给进程分配资源，初始化进程信息：例如分配进程号等等
就绪：所有的资源已经初始化完毕了，具备运行的能力，但是此刻还没有
cpu的执行授权。
运行：进程的程序已经在cpu中处于运行状态。

单核cpu:win98

cpu逻辑：主频xx赫兹
中断

进程和线程的区别：
进程和线程区别
进程可以向系统申请资源，分配给线程
多个线程会共用资源和数据
多线程和多进程实现的并发效果

进程之间的变量是互相独立的，不能够被互相修改
同一进程内的多线程，他们操作的变量是所有线程共享的变量，全局生效

python实现并发的方式
? 多进程：并发效果，想利用多核cpu
用到多核cpu
? 多线程：对于多io，且计算要求不高的应用
用单核cpu，有多io的时候
? 协程：

进程之间竞争资源也面临三个控制问题：
? 互斥（ mutual exclusion )指多个进程不能同时使用同一个资源；
? 死锁（ deadlock )指多个进程互不相让，都得不到足够的资源；
? 饥饿（ starvation )指一个进程一直得不到资源（其他进程可能轮流占用资源）。

2、进程在cpu中处于运行状态

这个时候进程需要向磁盘读写文件数据（网络数据传送）
sleep

运行----》阻塞（暂时不需要Cpu来执行，需要别的硬件去完成）----》就绪（cpu轮询）
----》（cpu有时间来运行的时候）运行
多个进程切换（进程没有阻塞）：运行—》就绪—》运行

3、父进程与子进程

import os

pid=os.fork() #生成了一个子进程，出现了2个进程同时开始向下执行：

if pid==0:
print(“执行子进程，子进程pid={pid},父进程ppid={ppid}”.
format(pid=os.getpid(),ppid=os.getppid()))
else:
print(“执行父进程，子进程pid={pid},父进程ppid={ppid}”.
format(pid=pid,ppid=os.getpid()))

从结果看：
if中的打印语句执行了
else中的打印语句也被执行了

多进程：产生了并发
父进程，在执行os.fork()，生成了一个子进程。然后从pid=os.fork()代码开始，同时
由两个进程在进行了，一个是主进程，一个是子进程。
主进程执行了if和else代码块，触发了else的执行。
子进程执行了if和else代码块，触发了if的执行。
pid被赋值了2次，被主进程赋值了一次（主进程号），被子进程赋值了一次（0）
主进程地址空间中（内存中，pid存的是进程号）----》触发的是else
子进程地址空间中（内存中，pid存的是0）—》触发if
多个子进程，pid的分配：
os.getpid()—>获得当前执行进程的进程号
os.getppid()—》获得是当前执行进程的父进程号。

4、程序

import os
import time
import random
pid=os.fork()  #生成了一个子进程，出现了2个进程同时开始向下执行：

i = random.randint(1,5)
print(pid,i)
time.sleep(i)


if pid==0:
    print("执行子进程，子进程pid={pid},父进程ppid={ppid}".\
format(pid=os.getpid(),ppid=os.getppid()))
else:
    print("执行父进程，子进程pid={pid},父进程ppid={ppid}".\
format(pid=pid,ppid=os.getpid()))
pid被赋值了2次，被主进程赋值了一次（主进程拿到了子进程号），被子进程赋值了一次（0）
主进程地址空间中（内存中，pid存的是子进程号）----》触发的是else
子进程地址空间中（内存中，pid存的是0）---》触发if
os.getpid()--->获得当前执行进程的进程号
os.getppid()---》获得是当前执行进程的父进程号。

import os
import time
import random
pid=os.fork()  #生成了一个子进程，出现了2个进程同时开始向下执行：

i = random.randint(1,5)
print(pid,i)
time.sleep(i)


if pid==0:
    print("执行子进程，子进程pid={pid},父进程ppid={ppid}".\
format(pid=os.getpid(),ppid=os.getppid()))
else:
    print("执行父进程，子进程pid={pid},父进程ppid={ppid}".\
format(pid=pid,ppid=os.getpid()))


import os,time
from multiprocessing import Process
 
def worker():
    print("hello")
 
def main():
    print("主进程执行中>>> pid={0}".format(os.getpid()))
 
    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()
 
    # 阻塞进程，这个进程必须执行完毕了，主进程才会执行剩余的代码
    #换句话：如果子进程执行的函数没有执行完毕，那就在这里死等执行
    #完，然后才会让主进程继续执行
    for i in range(2):
        ps[i].join()
 
    print("主进程终止")
 
if __name__ == '__main__':
    main()

#每个子进程必须指定一个任务函数，赋值给了target参数
#name=给进程起个名字
#args--->给任务函数传参数的。！

if name == ‘main’:#当文本本身被执行的时候，才会执行这个If
#这个文件被别人import的时候，这个if是不执行的
main()

import os,time
from multiprocessing import Process
import request

 
def worker():
    print("hello")
 
def main():
    print("主进程执行中>>> pid={0}".format(os.getpid()))
 
    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()
 
    # 阻塞进程，这个进程必须执行完毕了，主进程才会执行剩余的代码
    #换句话：如果子进程执行的函数没有执行完毕，那就在这里死等执行
    #完，然后才会让主进程继续执行
    for i in range(2):
        ps[i].join()  #阻塞了主进程
 
    print(ps)
    print("主进程终止")
 
if __name__ == '__main__':#当文本本身被执行的时候，才会执行这个If
                          #这个文件被别人import的时候，这个if是不执行的
    main()

#每个子进程必须指定一个任务函数，赋值给了target参数
#name=给进程起个名字
#args--->给任务函数传参数的。！

import os,time
from multiprocessing import Process
import request
import random
 
def worker():
    urls=["http://www.sohu.com","http://www.sogou.com","http://www.bing.com"]
    response = requests.get(urls[random.randint(0,2)])
    print(response.text[:100])
 
def main():
    print("主进程执行中>>> pid={0}".format(os.getpid()))
 
    ps=[]
    # 创建子进程实例
    for i in range(3):#主进程创建了2个子进程，创建的进程没有运行
        p=Process(target=worker,name="worker"+str(i),args=())
        ps.append(p)#把进程加入到列表中。
 
    # 开启进程
    for i in range(3):#遍历列表中的每一个进程对象，启动进程
        ps[i].start()
 
    # 阻塞进程，这个进程必须执行完毕了，主进程才会执行剩余的代码
    #换句话：如果子进程执行的函数没有执行完毕，那就在这里死等执行
    #完，然后才会让主进程继续执行
    for i in range(3):
        ps[i].join()  #阻塞了主进程
 
    print(ps)
    print("主进程终止")
 
if __name__ == '__main__':#当文本本身被执行的时候，才会执行这个If
                          #这个文件被别人import的时候，这个if是不执行的
    main()

#每个子进程必须指定一个任务函数，赋值给了target参数
#name=给进程起个名字
#args--->给任务函数传参数的。！