并发编程
a) 一台计算机上同时可以出现多个任务
b) 能够将多个任务所使用的资源隔离开
c) 当一个任务遇到输入输出工作的时候能够让另一个任务使用CPU去计算
4. 分时操作系统:降低了CPU的利用率,提高了用户的体验。
时间片轮转
5. 实时操作系统(实时的处理任务)
6. 网络操作系统
7. 分布式操作系统(多任务分给子系统处理)
并发:多个程序交替在同一个CPU上被计算
并行:多个程序同时在多个CPU上被计算
CPU是否在工作
异步:发布一个任务,不等待这个任务的结果就继续执行任务
同步:发布一个任务,等待获取这个任务的结果之后才继续执行任务
进程就是运行中的程序,每个进程在计算机中都有一个唯一的进程id,为PID
是进程中的一个单位,它不独立存在
import socketserver
socket是socketserve的底层模块
socketserver的网络连接这个操作是调用socket模块实现的
import socketserver
class Myserver(socketserver.BaseRequestHandler):
def handle(self):
conn=self.request
print(conn)
server = socketserver.ThreadingTCPServer(('127.0.0.1', 9999), Myserver)
server.serve_forever()
Python提供了multiprocessing。 multiprocessing模块用来开启子进程,并在子进程中执行我们定制的任务(比如函数),该模块与多线程模块threading的编程接口类似。multiprocessing模块的功能众多:支持子进程、通信和共享数据、执行不同形式的同步,>提供了Process、Queue、Pipe、Lock等组件。
示例:
import time
from multiprocessing import Process
def func(a,b,c):
time.sleep(1)
print(a,b,c)
if __name__ == '__main__':
Process(target=func,args=(1,2,3)).start() #这里的target是目标的意思,固定搭配
Process(target=func,args=(2,3,4)).start() #所有的Process()都是子进程,子进程都放在if下。
Process(target=func,args=(3,4,5)).start()
需要注意:args是传值,若只传一个值时,必须为元组形式。
p.start() #P是一个进程操作
p.terminate() 终止进程
p.is_alive() 进程是否存活
示例:
import time
import random
from multiprocessing import Process
def send_mail(name):
time.sleep(random.uniform(1,3))
print('已经给%s发送邮件完毕'%name)
if __name__ == '__main__':
lst = ['alex','yuan','宝元','太白']
p = Process(target=send_mail, args=('alex',))
p.start()
p.join() # 阻塞,直到p对应的进程结束之后才结束阻塞
print('所有的信息都发送完毕了')
守护进程是一个子进程,守护的是主进程。
结束条件:主进程的代码结束,守护进程也结束
import time
from multiprocessing import Process
def func():
for i in range(20):
time.sleep(0.5)
print('in func')
def func2():
print('start : func2')
time.sleep(5)
print('end : func2')
if __name__ == '__main__':
p = Process(target=func)
p.daemon = True # 表示设置p为一个守护进程
p.start()
p2 =Process(target=func2)
p2.start()
print('in main')
time.sleep(3)
print('finished')
p2.join()
import lock
lock=Lock()
lock.acquire()
内容
lock.release()
或
with lock:
内容
推荐用with lock,可以自动异常处理。
牺牲了效率,保证了数据安全
锁的应用:
当多个进程需要操作同一个文件/数据库的时候,会产生数据不安全,我们应该使用锁来避免多个进程同时修改一个文件
from multiprocessing import Queue # 可以完成进程之间通信的特殊的队列
# from queue import Queue # 不能完成进程之间的通信
from multiprocessing import Queue,Process
def son(q):
print('-->',q.get())
if __name__ == '__main__':
q = Queue()
Process(target=son,args=(q,)).start()
q.put('wahaha')
现有threading模块,后有multiprocessing模块,后者完全模仿前者,并且实现了池的功能concurrent.futures
import os
import time
from threading import Thread
def func():
time.sleep(1)
print('in func',os.getpid())
print('in main',os.getpid())
for i in range(20):
# func()
Thread(target=func).start()
from threading import active_count 返回当前有多少个正在工作的线程
print(active_count())
from threading import enumerate,Thread
def func():
print('in son thread')
Thread(target=func).start()
print(enumerate()) 返回一个存储着所有存活线程对象的列表
import time
from threading import Thread
def daemon_func():
while True:
time.sleep(0.5)
print('守护线程')
def son_func():
print('start son')
time.sleep(5)
print('end son')
t = Thread(target=daemon_func)
t.daemon = True 设置守护
t.start()
Thread(target=son_func).start()
time.sleep(3)
print('主线程结束')
数据不安全问题
在线程中也是会出现数据不安全问题(1.对全局变量进行修改 2.对某个值+= -= *= /*)
只能通过加锁来解决
from threading import Rlock,Thread
可以连续加锁
好处:控制进程的数量,节省资源的开销
示例:
import os
import time
from concurrent.futures import ProcessPoolExecutor 线程池
# def make(i):
# time.sleep(1)
# print('%s 制作螺丝%s'%(os.getpid(),i))
# return i**2
#
# if __name__ == '__main__':
# p = ProcessPoolExecutor(4) # 创建一个进程池
# for i in range(100):
# p.submit(make,i) # 向进程池中提交任务
# p.shutdown() # 阻塞 直到池中的任务都完成为止
# print('所有的螺丝都制作完了')
# p.map(make,range(100)) # submit的简便用法
# 接收返回值
# ret_l = []
# for i in range(100):
# ret = p.submit(make,i)
# ret_l.append(ret)
# for r in ret_l:
# print(r.result())
# ret = p.map(make, range(100))
# for i in ret:
# print(i)import os
import time
from concurrent.futures import ProcessPoolExecutor 线程池
# def make(i):
# time.sleep(1)
# print('%s 制作螺丝%s'%(os.getpid(),i))
# return i**2
#
# if __name__ == '__main__':
# p = ProcessPoolExecutor(4) # 创建一个进程池
# for i in range(100):
# p.submit(make,i) # 向进程池中提交任务
# p.shutdown() # 阻塞 直到池中的任务都完成为止
# print('所有的螺丝都制作完了')
# p.map(make,range(100)) # submit的简便用法
# 接收返回值
# ret_l = []
# for i in range(100):
# ret = p.submit(make,i)
# ret_l.append(ret)
# for r in ret_l:
# print(r.result())
# ret = p.map(make, range(100))
# for i in ret:
# print(i)
from urllib.request import urlopen
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def get_html(name,addr):
ret = urlopen(addr)
return {'name':name,'content':ret.read()}
def parser_page(ret_obj):
dic = ret_obj.result()
with open(dic['name']+'.html','wb') as f:
f.write(dic['content'])
url_lst = {
'name':'url',
'name':'url',
'name':'url',
'name':'url',
'name':'url',
}
t = ThreadPoolExecutor(20)
for url in url_lst:
task = t.submit(get_html,url,url_lst[url])
task.add_done_callback(parser_page)
是一个比线程还小的单位
协程不是操作系统可见的,是用户级别的,是代码控制切换的。
特点:从python代码级别的,完成代码在多个函数之间的切换。
协程(本质是一条线程,操作系统不可见)
是有程序员操作的,而不是由操作系统调度的
多个协程的本质是一条线程,所以多个协程不能利用多核
出现的意义 : 多个任务中的IO时间可以共享,当执行一个任务遇到IO操作的时候,
可以将程序切换到另一个任务中继续执行
在有限的线程中,实现任务的并发,节省了调用操作系统创建\销毁线程的时间
并且协程的切换效率比线程的切换效率要高
协程执行多个任务能够让线程少陷入阻塞,让线程看起来很忙
线程陷入阻塞的次数越少,那么能够抢占CPU资源就越多,你的程序效率看起来就越高
1.开销变小了
2.效率变高了
示例:
协程模块 帮助我们更加简单的进行函数之间的切换
import time
import gevent
def eat(): # 协程任务 协程函数
print('start eating')
gevent.sleep(1)
print('end eating')
def sleep(): # 协程任务 协程函数
print('start sleeping')
gevent.sleep(1)
print('end sleeping')
g1 = gevent.spawn(eat)
g2 = gevent.spawn(sleep)
# g1.join() # 阻塞,直到g1任务执行完毕
# g2.join() # 阻塞,直到g2任务执行完毕
gevent.joinall([g1,g2]) #合并上面两句
用了monkey.patch_all()之后,把所有导入的打成一个包,全部能使用。就可以不用上面的gevent.sleep(1).
from gevent import monkey
monkey.patch_all()
import time
import gevent
def eat(): # 协程任务 协程函数
print('start eating')
time.sleep(1)
print('end eating')
def sleep(): # 协程任务 协程函数
print('start sleeping')
time.sleep(1)
print('end sleeping')
g1 = gevent.spawn(eat) # 创建协程
g2 = gevent.spawn(sleep)
gevent.joinall([g1,g2]) # 阻塞 直到协程任务结束