|
|
# 多任务介绍
|
|
|
什么是多任务？
|
|
|
操作系统可以同时执行多个任务
|
|
|
|
|
|
现在的操作系统:windows mac linux unix
|
|
|
这些操作系统 都支持多任务
|
|
|
|
|
|
单核CPU如何实现多任务？
|
|
|
表面看，每个任务都是同时执行，实际上是每个任务在轮询着执行,只是因为CPU的调度太快，导致我们感觉像是所有任务都在同时执行
|
|
|
|
|
|
多核CPU如何实现多任务?
|
|
|
是真正实现了多个任务同时执行
|
|
|
|
|
|
并发：看上去一起执行，任务数大于CPU核心数
|
|
|
并行：一起执行，任务数必须小于等于CPU核心数
|
|
|
|
|
|
实现多任务的方式:
|
|
|
1、多进程方式
|
|
|
2、多线程方式
|
|
|
3、协程方式
|
|
|
4、多进程+多线程
|
|
|
|
|
|
### 没有多进程
|
|
|
|
|
|
```python
|
|
|
import time
|
|
|
def func():
|
|
|
while True:
|
|
|
print("this is a process2")
|
|
|
time.sleep(1.5)
|
|
|
if __name__ == '__main__':
|
|
|
while True:
|
|
|
print("this is a process1")
|
|
|
time.sleep(1)
|
|
|
func()
|
|
|
|
|
|
```
|
|
|
|
|
|
### multiprocessing 多进程
|
|
|
|
|
|
```python
|
|
|
from multiprocessing import Process
|
|
|
import time,os
|
|
|
|
|
|
def func(str):
|
|
|
|
|
|
#os.getpid 获取当前进程的进程号
|
|
|
|
|
|
#os.getppid 获取当前进程的父进程
|
|
|
|
|
|
while True:
|
|
|
print("this is process 2--%s--%s--%s"%(str,os.getpid(),os.getppid()))
|
|
|
time.sleep(1.5)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
print("父进程启动...--%s--%s"%(os.getpid(),os.getppid()))
|
|
|
# 创建子进程
|
|
|
# target 说明进程的任务
|
|
|
p = Process(target=func,args=("python",))
|
|
|
# 启动进程
|
|
|
p.start()
|
|
|
# 主进程中的
|
|
|
while True:
|
|
|
print("this is a process 1--%s--%s"%(os.getpid(),os.getppid()))
|
|
|
time.sleep(1)
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
|
### 让父进程等待子进程结束之后父进程再结束
|
|
|
|
|
|
```python
|
|
|
from multiprocessing import Process
|
|
|
from time import sleep
|
|
|
|
|
|
def func():
|
|
|
print("子进程启动...")
|
|
|
sleep(3)
|
|
|
print("子进程结束...")
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
print("父进程启动...")
|
|
|
p = Process(target = func)
|
|
|
p.start()
|
|
|
# sleep(1)
|
|
|
# 让父进程等待子进程结束之后父进程再结束
|
|
|
# timeout 超时时间 父进程的等待时间
|
|
|
p.join()
|
|
|
#执行后一直等待
|
|
|
print("父进程结束...")
|
|
|
```
|
|
|
|
|
|
### 在子进程中修改全局变量 对父进程中的全局变量没有影响
|
|
|
|
|
|
```python
|
|
|
from multiprocessing import Process
|
|
|
num = 100
|
|
|
def run1():
|
|
|
print("孙子进程开始...")
|
|
|
print("孙子进程结束...%s"%(num))
|
|
|
|
|
|
def run():
|
|
|
print("子进程开始...")
|
|
|
global num
|
|
|
num += 1
|
|
|
print(num)
|
|
|
p = Process(target=run1)
|
|
|
p.start()
|
|
|
p.join()
|
|
|
print("子进程结束...")
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
print("父进程开始...")
|
|
|
p = Process(target=run)
|
|
|
p.start()
|
|
|
p.join()
|
|
|
num += 2
|
|
|
# 在子进程中修改全局变量 对父进程中的全局变量没有影响
|
|
|
# 我们在创建子进程的时候 对全局变量做了一个备份
|
|
|
# 子进程和父进程的Num是两个完全不同的变量
|
|
|
# 所有进程对全局变量的修改 都不会影响其它进程
|
|
|
print("父进程结束...%d"%(num))
|
|
|
|
|
|
```
|
|
|
|
|
|
### 进程池
|
|
|
|
|
|
```python
|
|
|
from multiprocessing import Pool,Process
|
|
|
import time,random
|
|
|
def foo():
|
|
|
print("孙子进程开始...")
|
|
|
print("孙子进程结束...")
|
|
|
def func(__name__):
|
|
|
print("子进程%s启动..."%(__name__))
|
|
|
start = time.time()
|
|
|
time.sleep(random.choice([1,2,3]))
|
|
|
end = time.time()
|
|
|
print("子进程%s结束...耗时%.2f"%(__name__,end - start))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
print("父进程开始...")
|
|
|
# 创建进程池
|
|
|
# 如果没有参数 默认大小为自己电脑的CPU核心数
|
|
|
# 表示可以同时执行的进程数量
|
|
|
pp = Pool(2)
|
|
|
for i in range(4):
|
|
|
# 创建进程,放入进程池统一管理
|
|
|
pp.apply_async(func,args=(i,))
|
|
|
# 在调用join之前必须先关掉进程池
|
|
|
# 进程池一旦关闭 就不能再添加新的进程了
|
|
|
pp.close()
|
|
|
# 进程池对象调用join,会等待进程池中所有的子进程结束之后再结束父进程
|
|
|
pp.join()
|
|
|
print("父进程结束...")
|
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
|
|
# 多线程:
|
|
|
|
|
|
在一个进程内部，要同时干很多事，就需要同时执行多个子任务
|
|
|
那么我们把进程内的这些子任务叫做线程
|
|
|
|
|
|
线程的内存空间是共享的 每个线程都共享同一个进程的资源
|
|
|
|
|
|
模块:
|
|
|
1、_thread模块 低级模块
|
|
|
2、threading模块 高级模块 对_thread模块进行了封装
|
|
|
"""
|
|
|
### 创建线程
|
|
|
|
|
|
```python
|
|
|
import threading,time
|
|
|
|
|
|
def run(num):
|
|
|
print("子线程%s开始..."%(threading.current_thread().__name__))
|
|
|
time.sleep(2)
|
|
|
print(num)
|
|
|
time.sleep(2)
|
|
|
# current_thread 返回一个当前线程的实例
|
|
|
print("子线程%s结束..."%(threading.current_thread().__name__))
|
|
|
if __name__ == '__main__':
|
|
|
print("主线程%s启动..."%(threading.current_thread().__name__))
|
|
|
# 创建子线程
|
|
|
t = threading.Thread(target = run,args = (1,))
|
|
|
t.start()
|
|
|
t.join()
|
|
|
print("主线程%s结束..."%(threading.current_thread().__name__))
|
|
|
|
|
|
```
|
|
|
|
|
|
### 多线程共享资源
|
|
|
|
|
|
```python
|
|
|
import threading
|
|
|
|
|
|
num = 0
|
|
|
var = 0
|
|
|
def run(n):
|
|
|
global num
|
|
|
for i in range(1000000):
|
|
|
num += n
|
|
|
num -= n
|
|
|
def run1(n):
|
|
|
global var
|
|
|
for i in range(100):
|
|
|
var += n
|
|
|
var -= n
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
t1 = threading.Thread(target=run,args=(6,))
|
|
|
t2 = threading.Thread(target=run,args=(9,))
|
|
|
t3 = threading.Thread(target=run,args=(5,))
|
|
|
t3.start()
|
|
|
t1.start()
|
|
|
t2.start()
|
|
|
t1.join()
|
|
|
t2.join()
|
|
|
t3.join()
|
|
|
print("num = %s"%(num))
|
|
|
|
|
|
```
|
|
|
|
|
|
### 互斥锁
|
|
|
|
|
|
```python
|
|
|
import threading
|
|
|
|
|
|
创建锁对象
|
|
|
|
|
|
lock = threading.Lock()
|
|
|
num = 0
|
|
|
|
|
|
def run(n):
|
|
|
global num
|
|
|
for i in range(1000000):
|
|
|
# 加锁 为了确保下面代码只能由一个线程从头到尾的执行
|
|
|
# 会阻止多线程的并发执行，所以效率会大大降低
|
|
|
"""
|
|
|
lock.acquire()
|
|
|
try:
|
|
|
num = num - n
|
|
|
num = num + n
|
|
|
finally:
|
|
|
# 解锁
|
|
|
lock.release()
|
|
|
"""
|
|
|
with lock:
|
|
|
num = num + n
|
|
|
num = num - n
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
t1 = threading.Thread(target=run,args=(6,))
|
|
|
t2 = threading.Thread(target=run,args=(9,))
|
|
|
t1.start()
|
|
|
t2.start()
|
|
|
t1.join()
|
|
|
t2.join()
|
|
|
print("num = %s"%(num))
|
|
|
|
|
|
```
|
|
|
|
