day32 并发编程

并发编程

并发编程的理论

python中实现多进程

进程测试

import os

import time

while True:

    time.sleep(0.5)

    print("hahaha")

    print("self", os.getpid()) #获取自己的进程id

    print("parent",os.getppid())  #parent 获取父进程的id

开启进程的两种方式

from multiprocessing import Process

import os

#

def task(name):

    print(name)

    print("self",os.getpid())

    print("parent", os.getppid())

    print("task run")

#  windows创建子进程时  子进程会将父进程的代码加载一遍  导致重复创建子进程

#  所以一定要将 创建子进程的代码放到main的下面

if __name__ == '__main__':

    print("self", os.getpid())

    print("parent", os.getppid())

    p = Process(target=task, name="这是子进程!",kwargs={"name":"bgon"})  # 创建一个表示进程的对象  但并不是真正的创建进程

    p.start()  # 给操作系统发送通知 要求操作系统开启进程

# 创建进程的第二种方式  继承Process  覆盖run方法

# 在子进程启动以后会自动执行run方法

# 其优势是 可以自定义 进程的属性和行为 来完成一些额外任务 例如下载

# class MyProcess(Process):

#

#     def __init__(self,url):

#         self.url = url

#         super().__init__()

#

#     # 子类中的方法  只有run会被自动执行

#     def run(self):

#         print("下载文件...." , self.url)

#         print(" run run run!")

#

#     def task(self):

#         pass

#

# def task():

#     print(123)

# if __name__ == '__main__':

#     p = MyProcess("www.baidu.com/xx.mp4")

#     p.start()

进程间内存相互独立

from multiprocessing import Process

import time

a = 1000000000000

def task():

    global a

    print(id(a))

    a = 0

    print("子进程的",a)

if __name__ == '__main__':

    print(id(a))

    p = Process(target=task)

    p.start() # 给操作系统发送请求后 代码继续往下运行 至于子进程 什么时候创建 什么是执行 都跟当前进程没关系

    time.sleep(1)

    print("自己的",a)

# 子进程中的数据修改 不会影响父进程

父进程通过join()函数来等待子进程运行完,再往下运行

import time

from multiprocessing import Process

# def task():

#     print("上传文件....")

#     time.sleep(3)

#     print("上传结束...")

#

#

# # [进程1,进程2,进程3]

#

# if __name__ == '__main__':

#     p = Process(target=task)

#     p.start()

#

#     p.join() # 本质上  是提高了子进程优先级   当CPU在切换时 会优先切子进程

#

#     print("上传文件成功!")

def task(num):

    print("我是%s号 进程" % num)

    time.sleep(2)

    print("=========")

if __name__ == '__main__':

    start_time = time.time()

    ps = []

    for i in range(3):

        p = Process(target=task,args=(i,))

        p.start()

        print("----")

        # ps.append(p)

    for p in ps:

        p.join()

    print(time.time()-start_time)

    print("over")

process常用属性

from multiprocessing import  Process

import  time

def task():

    time.sleep(3)

    print("执行完毕!")

if __name__ == '__main__':

    p = Process(target=task,name="alex")

    p.start()

    print(p.name)

    # time.sleep(1)

    # print(p.is_alive())

    #

    # p.terminate() # 终结子进程的运行

    #

    # print(p.is_alive()) # 由于子进程被终结,所有不再存活,alive状态为False

    p.terminate()# 终止这个进程

    print(p.pid)

    p.daemon  # 守护进程

僵尸进程

假如子进程已经运行完了,但是主进程还在运行,也没有去对运行完的子进程做回收操作,那么这些子进程就一直占用着系统资源,直到父进程关闭,所有无用的占用着系统资源,是僵尸进程

import  time

import os

from multiprocessing import  Process

def task1():

    print("子进程 run")

    print(p.pid)

if __name__ == '__main__':

    for i in range(10):

        p = Process(target=task1)

        p.start()

        print(os.getpid())

    time.sleep(100000)

小结

1. 并发编程

让你的程序可以同时处理多个任务

2.并发的基石是多道技术

空间复用: 同一时间 内存存储了多个应用程序

         不同应用程序之间的内存是相互独立的

时间复用: 当一个程序遇到了IO操作时 会切换到其他应用程序  ,以此来提高CPU的利用率

多道技术的缺点: 当应用程序都是计算任务时 切换反而降低效率 (但是必须得切 才能保证多任务并发)

3.并发与并行

并发 多个事件 同时发生, 也称之为伪并行

并行 多个事件 同时进行,

阻塞和非阻塞 指的是程序的状态

就绪  运行  阻塞

4.两种使用进程的方式

1.直接创建Process对象 指定target参数

2.继承Process 覆盖run方法

5.join函数

提高优先级 使 父进程等待子进程结束

6.孤儿进程与僵尸进程路径(了解)

孤儿进程 是指 父进程已经终止了  但是自己还在运行  是无害的

孤儿进程会自定过继给操作系统

僵尸进程  是指 子进程执行完成所有任务 已经终止了但是 还残留一些信息(进程id 进程名)

但是父进程 没有去处理这些残留信息 导致残留信息占用系统内存

僵尸进程时有害的

当出现大量的僵尸进程时 会占用系统资源 可以把它父进程杀掉  僵尸就成了孤儿 操作系统会负责回收数据

巴特西

day32 并发编程

并发编程

进程测试

开启进程的两种方式

进程间内存相互独立

父进程通过join()函数来等待子进程运行完,再往下运行

process常用属性

僵尸进程

小结

1. 并发编程

2.并发的基石是多道技术

3.并发与并行

4.两种使用进程的方式

5.join函数

6.孤儿进程与僵尸进程路径(了解)

最新文章

热门文章

巴特西

day32 并发编程

并发编程

进程测试

开启进程的两种方式

进程间内存相互独立

父进程通过join()函数来等待子进程运行完,再往下运行

process常用属性

僵尸进程

小结

1. 并发编程

2.并发的基石是 多道技术

3.并发 与 并行

4.两种使用进程的方式

5.join函数

6.孤儿进程与僵尸进程路径(了解)

最新文章

热门文章

2.并发的基石是多道技术

3.并发与并行