路飞学城Python-Day30

 

---

11-僵尸进程与孤儿进程

现象：运行程序会产生父进程，在父进程中开子进程，这两个进程公用一个打印终端，运行的时候就只运行父进程，父进程虽然自己结束了，但是要等子进程结束完才会结束。

父进程可以开多个子进程，进程间是互相独立的，需要让父进程提供任何时刻都可以查看子进程状态的功能

僵尸进程是unix或linux系统提供的一种数据结构，即使子进程已经结束了，那么父进程也可以查看子进程的状态，父进程在自己结束的时候会发起系统命令wait，结束所有的僵尸子进程

1.所有的子进程都是要经历僵尸进程的状态的

2.僵尸进程是有害的，因为进程的pid还在占用，僵尸进程多了，会占用多个pid，如果父进程一直不结束，僵尸进程会一直不结束，那么新的子进程就会难开启

孤儿进程：子进程没结束，但是父进程结束了，那么子进程就会被init的进程接管，init是所有进程的父进程，孤儿进程是无害的

---

12-Process对象的其他属性或方法

如果主进程需要等待子进程结束以后才能运行，就需要join方法

只有主进程会在等，但是子进程不会等，会一直运行子进程

from multiprocessing import Process

import time

import os

def task():

print('%s is running.Parent is is %s' % (os.getpid(),os.getppid()))

time.sleep(4)

print('%s is done.Parent is is %s' % (os.getpid(),os.getppid()))

# windows操作系统一定要在main下执行Process

if __name__ == '__main__':

p1 = Process(target=task) #实例化一个对象

p2 = Process(target=task) #实例化一个对象

p1.start() #仅仅是给操作系统发送了一个信号

p2.start()

p1.join()

p2.join()

print('主进程结束',os.getpid(),os.getppid())

输出结果

 

start()给操作系统发送了一个信号,是由操作系统去调度是否启动线程，执行顺序是无法确定的！

from multiprocessing import Process

import time

import os

def task(name):

print('%s is running' % name)

time.sleep(4)

 

# windows操作系统一定要在main下执行Process

if __name__ == '__main__':

p1 = Process(target=task, args=('子进程1',)) #实例化一个对象

p2 = Process(target=task, args=('子进程2',)) #实例化一个对象

p3 = Process(target=task, args=('子进程3',))

p1.start() #仅仅是给操作系统发送了一个信号,是由操作系统去调度是否启动线程，执行顺序是无法确定的！

p2.start()

p3.start()

 

print('主进程结束',os.getpid(),os.getppid())

print(p1.pid)

start+join方法的执行方式最后的执行时间是以子进程的最长执行时间为准，并不是串行的

from multiprocessing import Process

import time

import os

def task(name, n):

    print('%s is running' % name)

    time.sleep(n)

 

# windows操作系统一定要在main下执行Process

if __name__ == '__main__':

    start = time.time()

    p1 = Process(target=task, args=('子进程1',1)) #实例化一个对象

    p2 = Process(target=task, args=('子进程2',3)) #实例化一个对象

    p3 = Process(target=task, args=('子进程3',5))

    p1.start() #仅仅是给操作系统发送了一个信号,是由操作系统去调度是否启动线程，执行顺序是无法确定的！

    p2.start()

    p3.start()

    p1.join()

    p2.join()

    p3.join()

    print('主进程结束',(time.time()-start))

串行的执行方法

from multiprocessing import Process

import time

import os

def task(name, n):

    print('%s is running' % name)

    time.sleep(n)

 

# windows操作系统一定要在main下执行Process

if __name__ == '__main__':

    start = time.time()

    p1 = Process(target=task, args=('子进程1',1)) #实例化一个对象

    p2 = Process(target=task, args=('子进程2',3)) #实例化一个对象

    p3 = Process(target=task, args=('子进程3',5))

    p1.start() #仅仅是给操作系统发送了一个信号,是由操作系统去调度是否启动线程，执行顺序是无法确定的！

    p1.join()

    p2.start()

    p2.join()

    p3.start()

    p3.join()

    print('主进程结束',(time.time()-start))

is_alive()->查看进程是否在运行

terminate()->交给操作系统，对这个进程进行回收（不是立刻回收，操作系统需要一点时间对内存进行释放）

name->进程的名称

---

13-练习题讲解

四 练习题

1、思考开启进程的方式一和方式二各开启了几个进程？

不算pycharm本身的进程

方式一：两个进程：1.py文件父进程；2.程序生成子进程

方式二：两个进程：2.py文件父进程；2.程序生成子进程

2、进程之间的内存空间是共享的还是隔离的？下述代码的执行结果是什么？

from multiprocessing import Process

 

n=100 #在windows系统中应该把全局变量定义在if __name__ == '__main__'之上就可以了

 

def work():

global n

n=0

print('子进程内: ',n)

 

 

if __name__ == '__main__':

p=Process(target=work)

p.start()

print('主进程内: ',n)

进程之间的内存空间是隔离的，执行结果

3、基于多进程实现并发的套接字通信？

服务端

import socket

from multiprocessing import Process

def talk(conn):

    while True:

        try:

            data = conn.recv(1024)

            if not data:break

            conn.send(data.upper())

        except ConnectionError:

            break

    conn.close()

 

 

 

def server():

    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

    server.bind(('127.0.0.1', 8080))

    server.listen(5)

    while True:

        conn, addr = server.accept()

        p = Process(target=talk, args=(conn,))

        p.start()

    server.close()

 

if __name__ == '__main__':

    server()

 

 

客户端

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

client.connect(('127.0.0.1', 8080))

while True:

msg = input('>>>>').strip()

if not msg:continue

client.send(msg.encode('gbk'))

data = client.recv(1024)

print(data.decode('gbk'))

4、思考每来一个客户端，服务端就开启一个新的进程来服务它，这种实现方式有无问题？

来一个客户端就要对服务端的机器启动一个进程，就要占内存空间，很多个客户端就会让服务端的内存爆炸！

 

三 练习题

1、改写下列程序，分别别实现下述打印效果

from multiprocessing import Process

import time

import random

 

def task(n):

time.sleep(random.randint(1,3))

print('-------->%s' %n)

 

if __name__ == '__main__':

p1=Process(target=task,args=(1,))

p2=Process(target=task,args=(2,))

p3=Process(target=task,args=(3,))

 

p1.start()

p2.start()

p3.start()

 

print('-------->4')

效果一：保证最先输出-------->4

-------->4

-------->1

-------->3

-------->2

 

from multiprocessing import Process

import time

import random

 

def task(n):

    time.sleep(random.randint(1,3))

    print('-------->%s' % n)

 

if __name__ == '__main__':

    p1=Process(target=task,args=(1,))

    p2=Process(target=task,args=(2,))

    p3=Process(target=task,args=(3,))

 

    p1.start()

    p2.start()

    p3.start()

    print('-------->4')

    p1.join()

    p2.join()

    p3.join()

效果二：保证最后输出-------->4

-------->2

-------->3

-------->1

-------->4

 

from multiprocessing import Process

import time

import random

 

def task(n):

    time.sleep(random.randint(1,3))

    print('-------->%s' % n)

 

if __name__ == '__main__':

    p1=Process(target=task,args=(1,))

    p2=Process(target=task,args=(2,))

    p3=Process(target=task,args=(3,))

 

    p1.start()

    p2.start()

    p3.start()

    p1.join()

    p2.join()

    p3.join()

    print('-------->4')

效果三：保证按顺序输出

-------->1

-------->2

-------->3

-------->4

 

from multiprocessing import Process

import time

import random

 

def task(n):

    time.sleep(random.randint(1,3))

    print('-------->%s' % n)

 

if __name__ == '__main__':

    p1=Process(target=task,args=(1,))

    p2=Process(target=task,args=(2,))

    p3=Process(target=task,args=(3,))

 

    p1.start()

    p1.join()

    p2.start()

    p2.join()

    p3.start()

    p3.join()

    print('-------->4')

2、判断上述三种效果，哪种属于并发，哪种属于串行？

效果一：并发

效果二：并发

效果三：串行

 

---

14-守护进程

主进程里设置子进程的目的是为了执行一个并发的任务

假设这个子进程的运行周期是伴随着主进程一起执行的，也就是主进程结束，不管子进程是不是执行完，都要结束，那么这就是守护进程

守护进程的特点：

1.守护进程在主进程代码结束后就终止

2.守护进程内无法再开启子进程，否则就会抛出异常

如果有两个任务需要并发执行，那么开一个主进程和一个子进程分别执行就可以，如果子进程的任务在主进程任务结束后就不需要存在了，那么该子进程在开启前就需要设置为守护进程，主进程代码运行结束，守护进程就会终止

from multiprocessing import Process

import time

 

 

def task(name):

    print('%s in running' % name)

    time.sleep(2)

 

if __name__ == '__main__':

    p = Process(target=task, args=(('子进程1',)))

    # 守护进程的设置一定是要在子进程开始之前设置守护进程

    p.daemon = True

    p.start()

    

    print('主进程结束')

 

# 练习题

from multiprocessing import Process

import time

 

def foo():

    print('123')

    time.sleep(1)

    print('end123')

 

 

def bar():

    print('456')

    time.sleep(3)

    print('end456')

 

 

if __name__ == '__main__':

    p1 = Process(target=foo)

    p2 = Process(target=bar)

    p1.daemon = True

    p1.start()

    p2.start()

    time.sleep(0.5)

    print('主进程结束')

 

主进程已经结束了，守护进程也会跟着结束

---

15-互斥锁

进程与进程之间的数据是不共享的，但是多个进程可以访问同一个文件数据或同一个打印终端，共享带来的问题就是竞争，但是竞争带来的问题就是错乱

from multiprocessing import Process

import time

 

 

def task(name):

    print('%s 1' % name)

    time.sleep(1)

    print('%s 2' % name)

    time.sleep(1)

    print('%s 3' % name)

 

 

if __name__ == '__main__':

    for i in range(3):

        p = Process(target=task, args=('进程%s' % i,))

        p.start()

这样会造成混乱，无法判断哪一个进程在执行

互斥锁：把本来共享的文件数据或者共享的终端数据，让进程一个一个的运行，把并发变成串行了，就不会混乱

但是效率就降低了，所以互斥锁就是牺牲了效率来保证自己的进程执行顺序不会混乱

from multiprocessing import Process,Lock

import time

 

 

def task(name,mutex):

    # 为自己的子进程加锁

    mutex.acquire()

    print('%s 1' % name)

    time.sleep(1)

    print('%s 2' % name)

    time.sleep(1)

    print('%s 3' % name)

#     释放子进程的锁

    mutex.release()

 

if __name__ == '__main__':

    mutex = Lock()

    for i in range(3):

        p = Process(target=task, args=('进程%s' % i,mutex))

        p.start()

---

16-模拟抢票

一个进程就像是一个抢票的人，一个人把自己的请求提出给12306的网站，提取数据，修改数据就成功

要求启用多个进程修改同一个数据

# 抢票的环节

# 1.先去看网站的票数

# 2.假设票数如果为0就不能再买票了

import time

import json

from multiprocessing import Process, Lock

 

def search(name):

time.sleep(1) #模拟网络延迟

dic = json.load(open('db.txt', 'r', encoding='utf-8'))

print('<%s> 查看剩余的票数[%s]' % (name, dic['count']))

 

 

def get(name):

time.sleep(1)

dic = json.load(open('db.txt', 'r', encoding='utf-8'))

if dic['count'] > 0:

dic['count'] -= 1

time.sleep(3)

json.dump(dic, open('db.txt', 'w', encoding='utf-8'))

print('<%s>购票成功！' % name)

 

 

def task(name, mutex):

search(name)

mutex.acquire()

get(name)

mutex.release()

 

 

if __name__ == '__main__':

mutex = Lock()

for i in range(10):

p = Process(target=task, args=('路人%s' % i, mutex))

p.start()

---

17-互斥锁与join的区别

join确实能把并发变成串行，但是整个代码全部都是串行了，实际上是不合理的

但是互斥锁可以对代码进行分割，只是部分变成串行，这样更合理

# 抢票的环节

# 1.先去看网站的票数

# 2.假设票数如果为0就不能再买票了

import time

import json

from multiprocessing import Process, Lock

 

def search(name):

    time.sleep(1) #模拟网络延迟

    dic = json.load(open('db.txt', 'r', encoding='utf-8'))

    print('<%s> 查看剩余的票数[%s]' % (name, dic['count']))

 

 

def get(name):

    time.sleep(1)

    dic = json.load(open('db.txt', 'r', encoding='utf-8'))

    if dic['count'] > 0:

        dic['count'] -= 1

        time.sleep(3)

        json.dump(dic, open('db.txt', 'w', encoding='utf-8'))

        print('<%s>购票成功！' % name)

    else:

        print('<%s>购票失败！'%name)

 

def task(name, ):

    search(name)

    # mutex.acquire()

    get(name)

    # mutex.release()

 

 

if __name__ == '__main__':

    # mutex = Lock()

    for i in range(10):

        p = Process(target=task, args=('路人%s' % i, ))

        p.start()

        p.join()

---

18-队列的使用

---

19-生产者消费者模型

---

20-JoinableQueue的使用

---

21-什么是线程

---

22-开启线程的两种方式

---

23-进程与线程的区别

---

24-Thread对象的其他属性或方法

---

25-守护线程

---

26-互斥锁

---

27-GIL的基本概念

---

28-GIL与自定义互斥锁的区别

---

29-GIL与多线程

---

30-死锁与递归锁

---

31-信号量

---

32-Event事件

---

33-定时器

---

34-线程queue

---

35-多线程实现并发的套接字通信

---

36-进程池线程池

---

37-异步调用与回调机制

---

38-进程池线程池小练习

---

39-协程介绍

---

40-协程实现与总结

---

41-greenlet模块

---

42-gevent模块

---

43-gevent异步提交任务

---

44-基于gevent模块实现并发的套接字通信

---

45-IO模型介绍

---

46-阻塞IO模型

---

47-非阻塞IO模型

---

48-多路复用IO模型

---

49-异步IO模型

---