背景知识
顾名思义，进程即正在执行的一个过程。进程是对正在运行程序的一个抽象。
进程的概念起源于操作系统，是操作系统最核心的概念，也是操作系统提供的最古老也是最重要的抽象概念之一。操作系统的其他所有内容都是围绕进程的概念展开的。
所以想要真正了解进程，必须事先了解操作系统
PS：即使可以利用的cpu只有一个（早期的计算机确实如此），也能保证支持（伪）并发的能力。将一个单独的cpu变成多个虚拟的cpu（多道技术：时间多路复用和空间多路复用+硬件上支持隔离），没有进程的抽象，现代计算机将不复存在
1，操作系统的作用：
1：隐藏丑陋复杂的硬件接口，提供良好的抽象接口
2：管理、调度进程，并且将多个进程对硬件的竞争变得有序
2， 多道技术：
1.产生背景：针对单核，实现并发
ps： 现在的主机一般是多核，那么每个核都会利用多道技术 有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个 cpu中的任意一个，具体由操作系统调度算法决定。
2.空间上的复用：如内存中同时有多道程序
3.时间上的复用：复用一个cpu的时间片 强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样 才能保证下次切换回来时，能基于上次切走的位置继续运行
一、什么是进程
进程：正在进行的一个过程或者说一个任务。而负责执行任务则是cpu。
二、进程与程序的区别
程序：仅仅是一堆代
进程：是指打开程序运行的过程
三、并发与并行
并发与并行是指cpu运行多个程序的方式
不管是并行与并发，在用户看起来都是‘同时'运行的，他们都只是一个任务而已，正在干活的是cpu，而一个cpu只能执行一个任务。
并行就相当于有好多台设备，可以同时供好多人使用。
而并发就相当于只有一台设备，供几个人轮流用，每个人用一会就换另一个人。
所以只有多个cpu才能实现并行，而一个cpu只能实现实现并发。
如上图所示：
串行：执行完A，再执行B，再执行C
并行：同时执行ABC
并发：交替执行ABC
3，开启子进程的两种方式
1，multiprocessing模块
python中的多线程无法利用多核优势，如果想要充分地使用多核CPU的资源（os.cpu_count()查看），在python中大部分情况需要使用多进程。Python提供了multiprocessing。
multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块threading的编程接口类似。
multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。
需要再次强调的一点是：与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。2，Process类的介绍
创建进程的类：
Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动） 强调： 1. 需要使用关键字的方式来指定参数 2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号
参数介绍：
group参数未使用，值始终为None
target表示调用对象，即子进程要执行的任务
args表示调用对象的位置参数元组，args=(1,2,'egon',)
kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
name为子进程的名称
方法介绍：
p.start()：启动进程，并调用该子进程中的p.run()
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():如果p仍然运行，返回True
p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程
属性介绍：
p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
p.name:进程的名称
p.pid：进程的pid
3，Process类的使用
注意：在windows中Process()必须放到# if name == 'main':下
创建并开启子进程的两种方式
方式一
方式一：
from multiprocessing import Process # 可以开启发起子进程调用
import time
def task(name):
print('%s is running' % name)
time.sleep(1)
print('%s is done' % name)
if name == 'main':
# Process(target=task,kwargs={'name':'子进程1'}) # kwargs可以按照字典的方式传参数，args按照位置的方式传参数
p = Process(target=task, args=('子进程1',)) # task后不加括号，加括号立马就会执行。args括号里面必须加逗号，组成一个元组
p.start() # 仅仅只是给操作系统发送了一个信号，由操作系统将父进程地址空间中的数据拷贝给子进程，作为子进程运行的初始状态，开启后再运行task
print('主')执行结果因为执行进程会有一段时间，所以先做打印操作
方式二
from multiprocessing import Process
import time
class MyProcess(Process):
def init(self, name):
super().__init__() # 将父类的功能进行重用
self.name = name
def run(self): # 这里一定要用run，下面start将调用这个run
print('%s is running' % self.name)
time.sleep(3)
print('%s is done' % self.name)if name == 'main':
p = MyProcess('子进程1')
p.start() # 触发上面的run方法
print('主')
4，查看进程的pid与ppid
使用pid和ppid可以分别查看子进程和父进程
from multiprocessing import Process
import time, os
def task():
print('%s is running,parent id is <%s>' % (os.getpid(), os.getppid())) # 查看子进程和父进程
time.sleep(3)
print('%s is done,parent id is <%s>' % (os.getpid(), os.getppid()))
if name == 'main':
p = Process(target=task,)
p.start()
print('主', os.getpid(), os.getppid()) # 查看子进程和父进程，此时父进程为pycharm主 7032 8916
14468 is running,parent id is <7032>
14468 is done,parent id is <7032>
5，Process对象的其他属性
join方法
在主进程运行过程中如果想并发地执行其他的任务，我们可以开启子进程，此时主进程的任务与子进程的任务分两种情况
情况一：在主进程的任务与子进程的任务彼此独立的情况下，主进程的任务先执行完毕后，主进程还需要等待子进程执行完毕，然后统一回收资源。
情况二：如果主进程的任务在执行到某一个阶段时，需要等待子进程执行完毕后才能继续执行，就需要有一种机制能够让主进程检测子进程是否运行完毕，在子进程执行完毕后才继续执行，否则一直在原地阻塞，这就是join方法的作用
join方法
from multiprocessing import Process
import time,os
def task():
print('%s is running,parent id is <%s>' % (os.getpid(), os.getppid()))
time.sleep(3)
print('%s is done,parent id is <%s>' % (os.getpid(), os.getppid()))
if name == 'main':
p = Process(target=task,)
p.start()
p.join() # 加入join方法后一定会等到子进程结束以后才会执行主进程
print('主', os.getpid(), os.getppid())
print(p.pid) # 验证了存在僵尸进程5064 is running,parent id is <5796>
5064 is done,parent id is <5796>
主 5796 8916
5064
join并发
from multiprocessing import Process
import time,os
def task(name,n):
print('%s is running' % name)
time.sleep(n)
if name == 'main':
start = time.time()
p1 = Process(target=task, args=('子进程1', 3)) # args根据位置传参
p2 = Process(target=task, args=('子进程2', 1))
p3 = Process(target=task, args=('子进程3', 2))
p_l = [p1, p2, p3]
p1.start()
p2.start()
p3.start()
p1.join() # 这三个仍然是并发执行，只是等待最长的程序执行完才结束
p2.join()
p3.join()
print('主', (time.time()-start))子进程1 is running
子进程2 is running
子进程3 is running
主 3.125457525253296
join串行
from multiprocessing import Process
import time,os
def task(name,n):
print('%s is running' % name)
time.sleep(n)
if name == 'main':
start = time.time()
p1 = Process(target=task, args=('子进程1', 3)) # args根据位置传参
p2 = Process(target=task, args=('子进程2', 1))
p3 = Process(target=task, args=('子进程3', 2))
p_l = [p1, p2, p3]
from multiprocessing import Process
import time,os
def task(name,n):
print('%s is running' % name)
time.sleep(n)
if name == 'main':
start = time.time()
p1 = Process(target=task, args=('子进程1', 3)) # args根据位置传参
p2 = Process(target=task, args=('子进程2', 1))
p3 = Process(target=task, args=('子进程3', 2))
p_l = [p1, p2, p3]
p1.start() # 每个都是执行完以后再进行下一步
p1.join()
p2.start()
p2.join()
p3.start()
p3.join()
print('主', (time.time()-start))子进程1 is running
子进程2 is running
子进程3 is running
主 6.322813510894775
6，守护进程
主进程创建子进程，然后将该进程设置成守护自己的进程，守护进程就好比崇祯皇帝身边的老太监，崇祯皇帝已死老太监就跟着殉葬了。
关于守护进程需要强调两点：
其一：守护进程会在主进程代码执行结束后就终止
其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children
如果我们有两个任务需要并发执行，那么开一个主进程和一个子进程分别去执行就ok了，如果子进程的任务在主进程任务结束后就没有存在的必要了，那么该子进程应该在开启前就被设置成守护进程。主进程代码运行结束，守护进程随即终止
from multiprocessing import Process
import time
def task(name):
print('%s is running' %name)
time.sleep(2)
# p = Process(target=time.sleep,args=(3,)) # 子进程不允许开启子进程,否则报错
# p.start()
if name == 'main':
p = Process(target=task, args=('子进程1',))
p.daemon = True #一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行
p.start()
# p.join() # 此处如果没有join,则还没等子进程开启,就随着主进程的结束而结束了
print('主') #只要终端打印出这一行内容，那么守护进程p也就跟着结束掉了
主进程结束，只会让守护进程跟着结束，但是其他子进程还是会继续运行
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()
print("main-------")main-------
end456
example
7，互斥锁
保证数据输出不会错乱
from threading import Thread,Lock
x = 0
mutex = Lock()
def task():
global x
mutex.acquire()
for i in range(100000):
x = x+1
mutex.release()
if name == 'main':
t1 = Thread(target=task)
t2 = Thread(target=task)
t3 = Thread(target=task)
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
print(x)9，队列的使用
解决大家共享硬盘文件，效率低以及使用内存解决加锁这个繁杂的步骤
multiprocessing模块提供了IPC(internet process communicate)进程之间的通信，队列以及管道，这两种方式都是使用消息传递的，队列就是管道加锁的实现
创建队列的类（底层就是以管道和锁定的方式实现）：
Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。
参数介绍：
maxsize是队列中允许最大项数，可以放置任意类型的数据，省略则无大小限制。
但需要明确：
1、队列内存放的是消息而非大数据
2、队列占用的是内存空间，因而maxsize即便是无大小限制也受限于内存大小
主要方法介绍：
q.put方法用以插入数据到队列中。数据不宜过大。
q.get方法可以从队列读取并且删除一个元素。
队列的使用
from multiprocessing import Process,Queue
q=Queue(3)
put ,get ,put_nowait,get_nowait,full,empty
q.put(1)
q.put(2)
q.put(3)
print(q.full()) # 判断是否满了
q.put(4) #再放就阻塞住了
print(q.get())
print(q.get())
print(q.get())
print(q.empty()) # 判断是否空了
print(q.get()) #再取就阻塞住了
10，生产者消费者模型
1，两者的介绍
为什么要使用生产者消费者模型
生产者指的是生产数据的任务，消费者指的是处理数据的任务，在并发编程中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。
什么是生产者和消费者模式
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
这个阻塞队列就是用来给生产者和消费者解耦的
2，两者的实现
from multiprocessing import Process, Queue
import time
def producer(q, name):
for i in range(3):
res = '包子%s' % i
time.sleep(0.5)
print('%s 生产了%s' % (name, res))
q.put(res)def consumer(q, name):
while True:
res = q.get()
if res is None: break
time.sleep(1)
print('%s 吃了%s' % (name, res))
if name == 'main':
# 容器
q = Queue()
# 生产者们
p1 = Process(target=producer, args=(q, '生产者1'))
p2 = Process(target=producer, args=(q, '生产者2'))
p3 = Process(target=producer, args=(q, '生产者3'))
# 消费者们
c1 = Process(target=consumer, args=(q, '消费者1'))
c2 = Process(target=consumer, args=(q, '消费者2'))
p1.start()
p2.start()
p3.start()
c1.start()
c2.start()
p1.join()
p2.join()
p3.join()
q.put(None)
q.put(None)
print('主')运行结果
生产者1 生产了包子0
生产者2 生产了包子0
生产者3 生产了包子0
生产者1 生产了包子1
生产者2 生产了包子1
生产者3 生产了包子1
生产者1 生产了包子2
消费者1 吃了包子0
生产者2 生产了包子2
消费者2 吃了包子0
生产者3 生产了包子2
主
消费者1 吃了包子0
消费者2 吃了包子1
消费者1 吃了包子1
消费者2 吃了包子1
消费者1 吃了包子2
消费者2 吃了包子2
消费者1 吃了包子2
4，多线程
1，什么是线程
在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程
线程顾名思义，就是一条流水线工作的过程（流水线的工作需要电源，电源就相当于cpu），而一条流水线必须属于一个车间，一个车间的工作过程是一个进程，车间负责把资源整合到一起，是一个资源单位，而一个车间内至少有一条流水线。
所以，进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。
多线程（即多个控制线程）的概念是，在一个进程中存在多个线程，多个线程共享该进程的地址空间，相当于一个车间内有多条流水线，都共用一个车间的资源。例如，北京地铁与上海地铁是不同的进程，而北京地铁里的13号线是一个线程，北京地铁所有的线路共享北京地铁所有的资源，比如所有的乘客可以被所有线路拉。
2，开启线程的两种方式
方式一：
import time
import random
from threading import Thread
def piao(name):
print('%s running' % name)
time.sleep(random.randrange(1, 3))
print('%s run end' % name)
if name == 'main':
t1 = Thread(target=piao, args=('qiuma',))
t1.start()
print('主线程')
方式二：
import time
import random
from threading import Thread
class MyThread(Thread):
def init(self, name):
super().__init__()
self.name = name
def run(self):
print('%s running' % self.name)
time.sleep(random.randrange(1, 3))
print('%s run end' % self.name)if name == 'main':
t1 = MyThread('quima')
t1.start()
print('主线程')
3，多线程与多进程的区别
①开启速度
在主进程下开启线程
import time
from threading import Thread
from multiprocessing import Process
def run(name):
print('%s running' % name)
time.sleep(2)
print('%s run end' % name)
if name == 'main':
t1 = Thread(target=run, args=('qiuma',))
t1.start()
print('主线程')
执行结果表明，几乎是t.start ()的同时就将线程开启了，然后先打印出了qiuma running，证明线程的创建开销极小
qiuma running
主线程
qiuma run end
在主进程下开启子进程
import time
from threading import Thread
from multiprocessing import Process
def piao(name):
print('%s running' % name)
time.sleep(1)
print('%s run end' % name)
if name == 'main':
p1 = Process(target=piao, args=('qiuma',))
p1.start()
# t1 = Thread(target=piao, args=('qiuma',))
# t1.start()
print('主进程')执行结果表明p.start ()将开启进程的信号发给操作系统后，操作系统要申请内存空间，让好拷贝父进程地址空间到子进程，开销远大于线程
主进程
qiuma running
qiuma run end
②pid的不同
1、在主进程下开启多个线程,每个线程都跟主进程的pid一样【pid(process id：进程的id号)】
from threading import Thread
import os
def task(): # 此处一定为task
print('子线程:%s' % (os.getpid())) # 一个进程内多个线程是平级的
if name == 'main':
t1 = Thread(target=task,)
t2 = Thread(target=task,)
t1.start()
t2.start()
print('主进程:', os.getpid())执行结果，主线程和子线程id都是一个值
执行结果
子线程:14912
子线程:14912
主线程:14912
2，开多个进程,每个进程都有不同的pid
from threading import Thread
from multiprocessing import Process
import os
def task():
print('子进程PID:%s 父进程的PID:%s' % (os.getpid(), os.getppid())) # 查看父进程和子进程的id
if name == 'main':
p1 = Process(target=task,)
p1.start()
print('主进程', os.getpid())执行结果
主进程 13580
子进程PID:3084 父进程的PID:13580
③总结两者的区别
1，启动线程的速度要比启动进程的速度快很多，启动进程的开销更大
2，在主进程下面开启的多个线程，每个线程都和主进程的pid（进程的id）一致
3，在主进程下开启多个子进程，每个进程都有不一样的pid
4，同一进程内的多个线程共享该进程的地址空间
5，父进程与子进程不共享地址空间，表明进程之间的地址空间是隔离的
5，守护线程
无论是进程还是线程，都遵循：守护xxx会等待主xxx运行完毕后被销毁
需要强调的是：运行完毕并非终止运行
1、对主进程来说，运行完毕指的是主进程代码运行完毕
2、对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕
详细解释
1、主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，
2、主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。
验证一：当主线程结束的时候，守护线程也跟着结束了
from threading import Thread
import time
def sayhi(name):
time.sleep(2)
print('%s say hello' % name) # 因为主进程结束以后，主线程也跟着结束，然后守护线程还没有打印，也跟着死了
if name == 'main':
t = Thread(target=sayhi, args=('qiuma',))
# t.setDaemon(True) #必须在t.start()之前设置
t.daemon = True # 这种方式和上面代码方式设置守护线程效果一样
t.start()
print('主线程')
print(t.is_alive())结果不会打印say hello字样
主线程
True
6，互斥锁
对于进程的互斥锁来说，将并行变为了串行，牺牲了效率，保证了安全
对于线程来说，一个进程内的多个线程是共享彼此的地址空间的，因此彼此之间数据也是共享的，由此代来的竞争可能将数据改乱。
from threading import Thread, Lock
import time
n = 100
def task():
global n
mutex.acquire() # 开始加锁
temp = n
time.sleep(0.1) # 未加锁之前，100个线程都停留在这并且temp都等于100
n = temp-1
mutex.release() # 解锁
if name == 'main':
mutex = Lock()
t_l = []
for i in range(100):
t = Thread(target=task)
t_l.append(t)
t.start()
for t in t_l:
t.join()
print('主', n)主 0
7，GIL全局解释器锁
GIL(Global Interpreter Lock)在Cpython解释器中，同一个进程下开启的多线程，同一时刻只能有一个线程执行，无法利用多核优势
1，GIL介绍
GIL本质就是一把互斥锁，既然是互斥锁，所有互斥锁的本质都一样，都是将并发运行变成串行，以此来控制同一时间内共享数据只能被一个任务所修改，进而保证数据安全。
可以肯定的一点是：保护不同的数据的安全，就应该加不同的锁。
首先确定一点：每次执行python程序，都会产生一个独立的进程。
test.py内容
import os,time
print(os.getpid())
time.sleep(1000)
打开终端执行
python3 test.py
在windows下查看
tasklist |findstr python
在linux下下查看
ps aux |grep python
在一个python的进程内，不仅有test.py的主线程或者由该主线程开启的其他线程，还有解释器开启的垃圾回收等解释器级别的线程，总之，所有线程都运行在这一个进程内，毫无疑问
1、所有数据都是共享的，这其中，代码作为一种数据也是被所有线程共享的（test.py的所有代码以及Cpython解释器的所有代码） 例如：test.py定义一个函数work（代码内容如下图），在进程内所有线程都能访问到work的代码，于是我们可以开启三个线程然后target都指向该代码，能访问到意味着就是可以执行。
2、所有线程的任务，都需要将任务的代码当做参数传给解释器的代码去执行，即所有的线程要想运行自己的任务，首先需要解决的是能够访问到解释器的代码。
综上：
如果多个线程的target=work，那么执行流程是
多个线程先访问到解释器的代码，即拿到执行权限，然后将target的代码交给解释器的代码去执行
解释器的代码是所有线程共享的，所以垃圾回收线程也可能访问到解释器的代码而去执行，这就导致了一个问题:对于同一个数据100，可能线程1执行x=100的同时，而垃圾回收执行的是回收100的操作，解决这种问题没有什么高明的方法，就是加锁处理，如下图的GIL，保证python解释器同一时间只能执行一个任务的代码
在Cpython解释器当中要利用多核优势，只能是开多进程，每个进程开一个线程去执行
2，GIL与Lock
锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据
然后，我们可以得出结论：保护不同的数据就应该加不同的锁。
GIL 与Lock是两把锁，保护的数据不一样，前者是解释器级别的（当然保护的就是解释器级别的数据，比如垃圾回收的数据），后者是保护用户自己开发的应用程序的数据，很明显GIL不负责这件事，只能用户自定义加锁处理，即Lock如下图
总结：GIL保证一个进程内的多个线程同一时间只能有一个执行，从而保证了python垃圾回收的线程安全，多个线程只能有一个运行。不同的数据，应该加上不同的锁，解释器级别的GIL 锁只能保护解释器级别的数据，用户自己开发的应用程序的数据需要自己加上另外一把锁来去保护。工作流程是线程们首先抢的不是mutex锁，而是GIL锁，将GIL当成是一种执行权限。
3，GIL与多线程
有了GIL的存在，同一时刻同一进程中只有一个线程被执行，进程可以利用多核，但是开销大，而python的多线程开销小，但却无法利用多核优势。
那么如何解决这个问题呢？
首先： 1、cpu到底是用来做计算的，还是用来做I/O的？cpu是用来做计算的
2、多cpu，意味着可以有多个核并行完成计算，所以多核提升的是计算性能
3、每个cpu一旦遇到I/O阻塞，仍然需要等待，所以多核对I/O操作没什么用处
1、对计算来说，cpu越多越好，但是对于I/O来说，再多的cpu也没用
2、当然对运行一个程序来说，随着cpu的增多执行效率肯定会有所提高（不管提高幅度多大，总会有所提高），这是因为一个程序基本上不会是纯计算或者纯I/O，所以我们只能相对的去看一个程序到底是计算密集型还是I/O密集型，从而进一步分析python的多线程到底有无用武之地
现在的计算机基本上都是多核，python对于计算密集型的任务开多线程的效率并不能带来多大性能上的提升，甚至不如串行(没有大量切换)，但是，对于IO密集型的任务效率还是有显著提升的。
4，多线程性能测试
如果并发的多个任务是计算密集型：多进程效率高
from multiprocessing import Process
from threading import Thread
import os,time
def work():
res=0
for i in range(100000000):
res*=i
if name == 'main':
l=[]
print(os.cpu_count()) # 打印本机的核心数
start=time.time()
for i in range(4):
# p=Process(target=work) #耗时5s多 # 显示多进程程序的执行时间
p=Thread(target=work) #耗时18s多 # 显示多线程程序执行的时间
l.append(p)
p.start()
for p in l:
p.join()
stop=time.time()
print('run time is %s' %(stop-start))
如果并发的多个任务是I/O密集型：多线程效率高
from multiprocessing import Process
from threading import Thread
import threading
import os,time
def work():
time.sleep(2)
print('===>')
if name == 'main':
l=[]
print(os.cpu_count()) #本机为4核
start=time.time()
for i in range(400):
# p=Process(target=work) #耗时12s多,大部分时间耗费在创建进程上
p=Thread(target=work) #耗时2s多
l.append(p)
p.start()
for p in l:
p.join()
stop=time.time()
print('run time is %s' %(stop-start))
应用：
多线程用于IO密集型，如socket，爬虫，web
多进程用于计算密集型，如金融分析
1406
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
