一、进程的并行和并发

并行：并行是指两者同时执行，比如赛跑，两个人都在不停的往前跑；（资源够用，比如三线程，四核的cpu）

并发：并发是指资源有限的情况下，两者交替轮流使用资源，比如一段路（单核cpu资源）同时只能过一个人，A走一段后，让给B，B用完继续给A，交替使用，目的拾提高速率。

并发与并行的区别：

并行是从微观上，也就是在一个精确的时间片刻，有不同的程序在执行，这就要求必须有多个处理器。

并发是从宏观上，在一个时间段上可以看出是同时执行的，比如一个服务器同时处理多个session。

 

二、同步异步阻塞非阻塞

状态介绍

在了解其他概念之前，我们首先要了解进程的几个状态。在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入几个状态：就绪，运行和阻塞。

1. 就绪(Ready)状态：当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。
2. 执行/运行（Running）状态当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。
3. 阻塞(Blocked)状态正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种，例如，等待I/O完成、申请缓冲区不能满足、等待信件(信号)等。

同步和异步

所谓同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。要么成功都成功，失败都失败，两个任务的状态可以保持一致。

所谓异步是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了整个任务就算完成了。至于被依赖的任务最终是否真正完成，依赖它的任务无法确定，所以它是不可靠的任务序列。

例子

比如我去银行办理业务，可能会有两种方式：

1. 第一种 ：选择排队等候；
2. 第二种 ：选择取一个小纸条上面有我的号码，等到排到我这一号时由柜台的人通知我轮到我去办理业务了；

第一种：前者(排队等候)就是同步等待消息通知，也就是我要一直在等待银行办理业务情况；

第二种：后者(等待别人通知)就是异步等待消息通知。在异步消息处理中，等待消息通知者(在这个例子中就是等待办理业务的人)往往注册一个回调机制，在所等待的事件被触发时由触发机制(在这里是柜台的人)通过某种机制(在这里是写在小纸条上的号码，喊号)找到等待该事件的人。

阻塞和非阻塞

阻塞和非阻塞这两个概念与程序（线程）等待消息通知(无所谓同步或者异步)时的状态有关。也就是说阻塞与非阻塞主要是程序（线程）等待消息通知时的状态角度来说的

例子

继续上面的那个例子，不论是排队还是使用号码等待通知，如果在这个等待的过程中，等待者除了等待消息通知之外不能做其它的事情，那么该机制就是阻塞的，表现在程序中,也就是该程序一直阻塞在该函数调用处不能继续往下执行。

相反，有的人喜欢在银行办理这些业务的时候一边打打电话发发短信一边等待，这样的状态就是非阻塞的，因为他(等待者)没有阻塞在这个消息通知上，而是一边做自己的事情一边等待。

注意：同步非阻塞形式实际上是效率低下的，想象一下你一边打着电话一边还需要抬头看到底队伍排到你了没有。如果把打电话和观察排队的位置看成是程序的两个操作的话，这个程序需要在这两种不同的行为之间来回的切换，效率可想而知是低下的；而异步非阻塞形式却没有这样的问题，因为打电话是你(等待者)的事情，而通知你则是柜台(消息触发机制)的事情，程序没有在两种不同的操作中来回切换。

同步/异步和阻塞/非阻塞

1、同步阻塞形式

效率最低。拿上面的例子来说，就是你专心排队，什么别的事都不做。

2 异步阻塞形式

如果在银行等待办理业务的人采用的是异步的方式去等待消息被触发（通知），也就是领了一张小纸条，假如在这段时间里他不能离开银行做其它的事情，那么很显然，这个人被阻塞在了这个等待的操作上面。

异步操作是可以被阻塞住的，只不过它不是在处理消息时阻塞，而是在等待消息通知时被阻塞。

3 同步非阻塞形式

实际上是效率低下的。

想象一下你一边打着电话一边还需要抬头看到底队伍排到你了没有，如果把打电话和观察排队的位置看成是程序的两个操作的话，这个程序需要在这两种不同的行为之间来回的切换，效率可想而知是低下的。

4 异步非阻塞形式

效率更高，

因为打电话是你(等待者)的事情，而通知你则是柜台(消息触发机制)的事情，程序没有在两种不同的操作中来回切换。

比如说，这个人突然发觉自己烟瘾犯了，需要出去抽根烟，于是他告诉大堂经理说，排到我这个号码的时候麻烦到外面通知我一下，那么他就没有被阻塞在这个等待的操作上面，自然这个就是异步+非阻塞的方式了。

很多人会把同步和阻塞混淆，是因为很多时候同步操作会以阻塞的形式表现出来，同样的，很多人也会把异步和非阻塞混淆，因为异步操作一般都不会在真正的IO操作处被阻塞。

5、阻塞非阻塞与同步异步的区别

便于理解：https://www.zhihu.com/question/19732473

三、如何开启进程

注意：win中要想开启进程，必须放在main里面。

1、开启进程先实例化，得到进程对象
2、必须调用start方法

 1 """
 2 并发：一个时间段上可以看出是同时执行的
 3 并行：就是在一个精确的时间片刻
 4 
 5 
 6 同步和异步：同步和异步关注的是消息通信机制
 7 阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态.
 8 """
 9 
10 from multiprocessing import Process
11 
12 
13 import time
14 def write():
15     time.sleep(1)
16     with open('abc', 'a') as f:
17         f.write('ly is dsb')
18         f.write('\n')
19 
20 
21 # win中要想开启进程，必须放在main里面
22 if __name__ == '__main__':
23     # 1.开启进程先实例化，得到进程对象
24     # target => 你要执行的任务，  函数
25     p = Process(target=write)  # 通知操作系统取开启进程
26 
27     # 2.必须调用start方法
28     p.start()
29 
30     p1 = Process(target=write)
31 
32     # 2.必须调用start方法
33     p1.start()

 

四、Process类的参数，方法，属性

1、参数

Process（target = None, name = None, args = None, kwargs = None）

target = 方法，函数

name = 进程名（可以用来限制进程）

两种传值的方式：

args = （）以元组的方式传参，按位置传

kwargs = （）以字典的方式传参，

 

2、方法

p.Process()：

p.start()

启动一个子进程，而启动子进程需要时间，但不会影响后面代码的运行

p.run()

调用run方法，不会启动子进程，代码串行执行。第二种开启进程的方式，需要用到run方法，重写run方法

p.join()

 等待子进程执行完毕，再执行主进程。

p.terminate()

杀死一个进程，杀死需要一个过程，不能马上执行完

p.is_alive()

判断一个进程是否存活

 

3、属性

p.name    进程名

p.pid    进程id号

p.daemon = True  设置守护进程：主进程结束，子进程结束（放在start之前）

 

五、获取进程ID号以及同时运行多个进程

1、获取进程ID号

import os

os.getpid()    获取子进程的ID号

os.getppid()      获取父进程的ID号

 

2、同时运行多个进程

版本一：让进程按顺序执行

 1 from multiprocessing import Process
 2 import time
 3 import os
 4 def write(i):
 5     time.sleep(1)
 6     print("第%s个进程" % i)
 7 
 8 def write1(name):
 9 
10     time.sleep(3)
11     print("write1")
12 
13 if __name__ == '__main__':
14 
15     ll = []
16 
17     for i in range(5):
18         p = Process(target=write, args=(i,), )  # 通知操作系统取开启进程
19 
20         p.start()
21 
22         p.join()

版本二：

 1 from multiprocessing import Process
 2 import time
 3 import os
 4 def write(i):
 5     time.sleep(1)
 6     print("第%s个进程" % i)
 7 
 8 def write1(name):
 9 
10     time.sleep(3)
11     print("write1")
12 
13 if __name__ == '__main__':
14 
15     ll = []
16 
17     for i in range(5):
18         p = Process(target=write, args=(i,), )  # 通知操作系统取开启进程
19 
20         p.start()
21 
22         ll.append(p)
23 
24     for j in ll:
25         j.join()

 

六、高并发的tcp服务端

 1 import socket
 2 from  multiprocessing import  Process
 3 
 4 def task(sock):
 5     # 1024 bytes
 6     while True:
 7         # 客户端非正常断开，需要捕捉异常
 8         try:
 9             data = sock.recv(1024)
10             if len(data) == 0:  # 当客户端主动断开时，接收的数据为空
11                 break
12             print(data)
13 
14             sock.send(data.upper())
15         except Exception as e:
16             print(e)
17             break
18 
19     sock.close()
20 
21 
22 print("正在接收客户端消息：")
23 
24 if __name__ == '__main__':
25     server = socket.socket()
26 
27     server.bind(('127.0.0.1', 8082))
28 
29     server.listen(5)
30     while True:
31         sock, addr = server.accept()
32         print(sock)
33         print(addr)
34 
35         p = Process(target=task, args=(sock, ))
36         p.start()
37 
38 
39     server.close()

 

七、进程锁 

 1 import os
 2 import time
 3 
 4 from multiprocessing import Process, Lock
 5 def task(i, lock):
 6 
 7     # 第一步开始上锁
 8     lock.acquire()
 9 
10     print("第%s个，进程id：%s开始执行了" % (i, os.getpid()))
11     time.sleep(2)
12     print("第%s个，进程id：%s执行结束了" % (i, os.getpid()))
13 
14     # 释放锁
15     lock.release()
16 
17 if __name__ == '__main__':
18 
19     # 实例化得到一把锁,  5个进程用的是同一把锁
20     lock = Lock()
21     for i in range(5):
22         p = Process(target=task, args=(i, lock))
23         p.start()

 

标签：__,异步,day36,阻塞,进程,import,等待
来源： https://www.cnblogs.com/Gnomeshghy/p/15036678.html