10.1 操作系统
分时多道技术
10.2 进程、线程
10.3 GIL: 全局解释锁
10.4 锁
同步锁
死锁 递归锁
10.5 同步 与 异步
同步事件、信号量
队列
10.6 生产者-消费者模型
10.7 多进程模块
10.8 进程间通信
进程队列Queue
管道
manager
数据同步
进程池
10.1 操作系统
操作系统的作用：
1：隐藏丑陋复杂的硬件接口，提供良好的抽象接口
2：管理、调度进程，并且将多个进程对硬件的竞争变得有序
多道技术：
1.产生背景：针对单核，实现并发
ps：
现在的主机一般是多核，那么每个核都会利用多道技术
有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个
cpu中的任意一个，具体由操作系统调度算法决定。
2.空间上的复用：如内存中同时有多道程序
3.时间上的复用：复用一个cpu的时间片
强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样
才能保证下次切换回来时，能基于上次切走的位置继续运行
多道程序设计：
在不同用户遇到IO进行切换操作，当用户A IO阻塞时，切换到B用户，当B执行完再处理A
SPOOLING： 外部设备联机操作
分时操作系统： 多个联机操作 + 多道程序设计 类似原先网吧的分屏技术
10.2 进程、线程
进程
本质上就是一段程序运行过程（一段抽象概念） 就是一个过程
定义： 进程就是一个程序在数据集上的一次动态执行过程
进程一般是由程序、数据集、进程控制块三部分组成
数据集： 程序运行过程中所需的一切数据资源
进程控制块： 目的是用于切换，状态保存，恢复操作
进程切换： IO切换，时间轮询切换
进程：最小的资源单元
线程：
特点：共享整个进程的内存，数据集
单个的线程不可能脱离进程而存在
一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以并发执行
线程：最小的执行单元，微进程 (运行实例)
一个进程至少得有一个线程
程序运行在内存中，CPU在取内存中的数据拿出并执行，
1.什么是进程?进程和程序之间有什么区别?
进程:一个程序的执行实例称为进程;
每个进程都提供执行程序所需的资源。
进程有一个虚拟地址空间、可执行代码、对系统对象的开放句柄、一个安全上下文、一个惟一的进程标识符、环境变量、一个优先级类、最小和最大工作集大小，以及至少一个执行线程;
每个进程都由一个线程启动，这个线程通常被称为主线程，但是可以从它的任何线程中创建额外的线程;
程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程;
程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。
在多道编程中，我们允许多个程序同时加载到内存中，在操作系统的调度下，可以实现并发地执行，大大提高了CPU的利用率
2.什么是线程?
进程的缺点有:
进程只能在一个时间干一件事，如果想同时干两件事或多件事，进程就无能为力了。
进程在执行的过程中如果阻塞，例如等待输入，整个进程就会挂起，即使进程中有些工作不依赖于输入的数据，也将无法执行。
线程是操作系统能够进行运算调度的最小单位。
它被包含在进程之中，是进程中的实际运作单位。
一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务
线程是一个执行上下文，它是一个CPU用来执行指令流的所有信息。
3.进程和线程之间的关系?
线程共享创建它的进程的地址空间;进程有自己的地址空间。(内存地址)
线程可以直接访问其进程的数据段;进程有自己的父进程数据段的副本。
线程可以直接与进程的其他线程通信;进程必须使用进程间通信来与兄弟进程通信。
新线程很容易创建;新进程需要复制父进程。
线程可以对同一进程的线程进行相当大的控制;进程只能对子进程执行控制。
对主线程的更改(取消、优先级更改等)可能会影响流程的其他线程的行为;对父进程的更改不会影响子进程。
程序计数器： 真正保存的就是一个内存地址， 上下文切换的时候在取出上一次的运行状态，并进程恢复执行操作
############# 进程运行，生成子线程，主子线程开始顺序运行，遇至 IO阻塞开始执行下一条。
import threading
import time
def Tv():
print(time.ctime())
print('look Tv')
time.sleep(2)
print(time.ctime())
# 生成一个对象
T=threading.Thread(target=Tv)
# 跟socket一样调用threading父类的start方法执行
T.start()
print('start ')
# 结果
Thu Jan 18 15:00:50 2018
look Tv
start
Thu Jan 18 15:00:52 2018############ 线程之间可以并发执行 顺序执行 ，执行完主线程然后再执行子线程，直到程序退出
import threading
import time
def Tv():
print('tv show start time ',time.ctime())
print('look Tv')
time.sleep(2)
print('tv show end time ',time.ctime())
def Eat():
print('eat start time ',time.ctime())
print('eat ')
time.sleep(2)
print('eat end time ',time.ctime())
# 生成一个对象
T=threading.Thread(target=Tv)
# 跟socket一样调用threading父类的start方法执行
T.start()
T2=threading.Thread(target=Eat)
T2.start()
print('start ')
## 结果
tv show start time Thu Jan 18 15:06:00 2018
look Tv
eat start time Thu Jan 18 15:06:00 2018
eat
start
tv show end time Thu Jan 18 15:06:02 2018
eat end time Thu Jan 18 15:06:02 2018######## 当程序中有join时，会先执行子线程的程序，最后再去执行主线程的代码，并发运行
import threading
import time
def Tv():
print('tv show start time ',time.ctime())
print('look Tv')
time.sleep(2)
print('tv show end time ',time.ctime())
def Eat():
print('eat start time ',time.ctime())
print('eat ')
time.sleep(2)
print('eat end time ',time.ctime())
# 生成一个对象
T=threading.Thread(target=Tv)
T2=threading.Thread(target=Eat)
T.start()
T2.start()
T.join()
T2.join()
print('start ')
## 结果
tv show start time Thu Jan 18 15:14:15 2018
look Tv
eat start time Thu Jan 18 15:14:15 2018
eat
tv show end time Thu Jan 18 15:14:17 2018
eat end time Thu Jan 18 15:14:17 2018
start######## 如果join在start前，那么就会先执行子线程中的程序 然后再执行下一段子线程，就无法实现并发的效果了
setDaemon(True) 守护线程
子线程是否要守护主线程, 当主线程退出之后， 子线程也会直接跟着退出
其它方法：
Thread实例对象的方法
# isAlive(): 返回线程是否活动的。
# getName(): 返回线程名。
# setName(): 设置线程名。
# 继承 threading.Thread 需要重写一下run方法
class Mythread(threading.Thread):
def __init__(self,num):
# 继承父类的 init方法
threading.Thread.__init__(self)
self.num = num
# 重写run方法 跟sockserver的header方法一样
def run(self):
print('测试一下: %s' %self.num)
time.sleep(2)
if __name__ == '__main__':
t1=Mythread(11111)
t2=Mythread(22222)
t1.start() # 使用start方法，类继承方法必须要有run方法
t2.start()
print(t1.getName()) # Thread-1
t1.setName('test_Thread')
print(t1.getName()) # test_Thread
print('主线程跑起来')
# 结果
测试一下: 11111
测试一下: 22222
主线程跑起来10.3. python GIL全局解释器锁
无论你启多少个线程，你有多少个cpu, Python在执行的时候会淡定的在同一时刻只允许一个线程运行
任务分为两部分：IO密集型：计算密集型
sleep等同于IO操作
对于IO密集型的任务： python的多线程的是有意义的
可以采用多进程+协程(也解决IO密集型问题)
对于计算密集型的任务： python的多线程就不推荐，
10.4 锁
同步锁：
lock=threading.Lock() 创建一个对象
lock.acquire() 锁住，只能有一个线程被执行
代码块
lock.release() 执行完释放
####### 例一
import threading
import time
num=100
def Nums():
global num
lock.acquire()
temp=num
temp-=1
# 当睡眠时间为1时，结果一定是99 同时执行100个线程,每次取出的结果都为99
time.sleep(0.01)
num=temp
lock.release()
print('k')
s=[]
# 增加同步锁功能就跟异步类似，但它也能同时并发操作，比如在加锁前与加锁后进行打印。
lock=threading.Lock() # 同步锁
if __name__ == '__main__':
for i in range(100):
i=threading.Thread(target=Nums)
i.start() #每个对象都需要start一次
s.append(i) #附加
for x in s:
x.join() # 最后一次的join
print(num) # 主线程死锁 递归锁：
线程间共享多个资源，两个线程分别占有一部分资源，并且同时等待对方释放，就会造成死锁，
##### 死锁 例一
import threading
import time
class Mythread(threading.Thread):
def Ltest(self):
A.acquire()
print(self.name,'Ltest1_A',time.ctime())
time.sleep(2)
print(self.name,'Ltest1_B',time.ctime())
B.acquire()
print(self.name,'Ltest1_A',time.ctime())
time.sleep(2)
print(self.name,'Ltest1_B',time.ctime())
B.release()
A.release()
def Ltest2(self):
B.acquire()
print(self.name, 'Ltest1_A', time.ctime())
time.sleep(2)
print(self.name, 'Ltest1_B', time.ctime())
A.acquire()
print(self.name, 'Ltest2_A', time.ctime())
time.sleep(2)
print(self.name, 'Ltest2_B', time.ctime())
A.release()
B.release()
def run(self):
self.Ltest()
self.Ltest2()
li=[]
A = threading.Lock()
B = threading.Lock()
if __name__ == '__main__':
for i in range(2):
f=Mythread()
f.start()
li.append(f)
# 执行最后一个数值
for x in li:
x.join()
# Ltest第一次执行完所有的锁并释放，再执行Ltest2，B锁开始运行，然后run方法调用Ltest方法(再次执行A锁,A锁运行完执行B锁的), 死锁就出来了,因为Ltest2的B锁还没有释放
## 结果
Thread-1 L1_test1_A Fri Jan 19 17:28:29 2018
Thread-1 L1_test1_B Fri Jan 19 17:28:31 2018
Thread-1 L2_test1_A Fri Jan 19 17:28:31 2018
Thread-1 L2_test1_B Fri Jan 19 17:28:33 2018
Thread-1 L3_test2_A Fri Jan 19 17:28:33 2018
Thread-2 L1_test1_A Fri Jan 19 17:28:33 2018
Thread-1 L3_test2_B Fri Jan 19 17:28:35 2018
Thread-2 L1_test1_B Fri Jan 19 17:28:35 2018## 死锁解决办法 递归锁
rlock 自身维护着一个计数器，每次加一个锁conut +1 执行完减一
import threading
import time
class Mythread(threading.Thread):
def Ltest(self):
R.acquire()
print(self.name,'L1_test1_A',time.ctime())
time.sleep(2)
print(self.name,'L1_test1_B',time.ctime())
R.acquire()
print(self.name,'L2_test1_A',time.ctime())
time.sleep(2)
print(self.name,'L2_test1_B',time.ctime())
R.release()
R.release()
def Ltest2(self):
R.acquire()
print(self.name, 'L3_test2_A', time.ctime())
time.sleep(2)
print(self.name, 'L3_test2_B', time.ctime())
R.acquire()
print(self.name, 'L4_test2_A', time.ctime())
time.sleep(2)
print(self.name, 'L4_test2_B', time.ctime())
R.release()
R.release()
def run(self):
self.Ltest()
self.Ltest2()
li=[]
# A = threading.Lock()
# B = threading.Lock()
R=threading.RLock() # 递归锁
if __name__ == '__main__':
for i in range(2):
f=Mythread()
f.start()
li.append(f)
# 执行最后一个数值
for x in li:
x.join()
# 结果
太长了，资源都是抢占方式运行，所以显示出来的信息是不按顺序打印的10.5 同步与异步
同步 与 异步
同步： 当进程执行到IO操作(等待外部数据)的时候， 如socket recv与send一发一收时，等。同步
异步不等，一直等到数据接收成功，再回来处理
信号量和同步对象 # 需了解的东西
同步事件
让两个线程之间处于一个同步状态
event.wait() # 等待 需要设置一个flag位，False就表示阻塞
event.set() # 如果设置这个了 就表示为True
event.clear() # 将set设置为false
###### 例一
import threading
import time
class Boss(threading.Thread):
def run(self):
print('Boss: 项目急,大家在加油一下')
print(events.isSet())
# 创建事件对象,设置flag为True
events.set()
time.sleep(3)
print(events.isSet())
print('Boss: 下班,大家辛苦啦')
events.set()
class Worker(threading.Thread):
def run(self):
# 默认是faluse,等待其它事件为true时执行
events.wait()
# 线程并发操作,沉睡时间取决于上一个线程的最大时间
print('Worker: 回去又得好慢了,加油干')
time.sleep(1)
events.clear()
events.wait()
print('Worker: 下班咯')
Li_dist=[]
if __name__ == '__main__':
events=threading.Event() # 创建一个事件对象
for L in range(5):
Li_dist.append(Worker())
Li_dist.append(Boss())
for x in Li_dist:
x.start()
for J in Li_dist: # 最后一个线程join
J.join()
print('结束循环')
# 结果
Boss: 项目急,大家在加油一下
False
Worker: 回去又得好慢了,加油干*5
Boss: 下班,大家辛苦啦
Worker: 下班咯*5
结束循环信号量：
允许有多少线程同时运行
#### 例一
import threading
from time import sleep
class Mythread(threading.Thread):
def run(self):
# 增加一把锁,同时3次
sem.acquire()
print(self.name)
sleep(1)
# 释放锁
sem.release()
Li=[]
# 定义允许同时能有多少个线程能同时运行，类似电梯，一次只能多重
sem = threading.Semaphore(3)
if __name__ == '__main__':
for i in range(20):
Li.append(Mythread())
for L in Li:
L.start()
# 结果
# 每次打印三个队列------生产者消费者模型
# 队列是用来解决多线程安全的，有多线程的出现才有队列
队列优先级
1、先进先出
2、先进后出
3、优先级
1、先进先出
### 例一
import queue # 线程队列
# 首先先创建一个对象 比如列表Lis=[]
q=queue.Queue()
q.put(123)
q.put('asf')
q.put({'name':'xiong'})
while 1:
data=q.get()
print(data)
print('-----')
# 结果
123
-----
asf
-----
{'name': 'xiong'}
-----
# 需要注意的是这里并没有打印完，它一直在这里阻塞，同步状态,一直等待下一个值的接收
# 例二：
q=queue.Queue(3)
#设置最大put值,当定义的put值，超过了定义的值的时候，会直接阻塞
# 例三：
q.put('adsf',False)
# 自已定义一个阻塞, 默认是True
raise Full
queue.Full
# 当定义的值超过例二定义的范围时，会报full错误
2、先进后出
q=queue.LifoQueue(3)
# 好比类似一个细长的水壶,往里放小石子，最前的就是最后倒出来的.
3、优先级
import queue
q=queue.PriorityQueue()
q.put([3,123]) #定义优先级,值越小优先级越高
q.put([5,'asf'])
q.put([4,{'name':'xiong'}])
while 1:
data=q.get()
print(data)
print('-----')
[3, 123]
-----
[4, {'name': 'xiong'}]
-----
[5, 'asf']
-----
# 最后这里打印的也是会一直阻塞，等待下一个值的输入
# 其它方法
import queue
q=queue.PriorityQueue()
q.put([3,123])
q.put([5,'asf'])
q.put([4,{'name':'xiong'}])
print('qsize: ',q.qsize())
print('是否full:',q.full())
print('是否为空：',q.empty())
while 1:
data=q.get()
print(data)
print('-----')
# 结果
qsize: 3 # 这里不是对象定义的值，而是根据put做出的判断,有多少个put就有多少个值
是否full: False # 没满
是否为空： False # 不是为空， 可以用于其它程序的判断，比如我只让你输入二个，你输入三个就报错
[3, 123]
-----
[4, {'name': 'xiong'}]
-----
[5, 'asf']
-----
q.task_done()：使用者使用此方法发出信号，表示q.get()的返回项目已经被处理。如果调用此方法的次数大于从队列中删除项目的数量，将引发ValueError异常
q.join():生产者调用此方法进行阻塞，直到队列中所有的项目均被处理。阻塞将持续到队列中的每个项目均调用q.task_done（）方法为止10.6 生产者-消费者模型
### 例一
import queue
import time
import threading
# 生成一个线程对象
q=queue.Queue()
def Producer(name):
count=0
while count < 10:
time.sleep(2)
q.put(count)
# q.task_done() # 发送包子已经制作好
print('Producer %s makeing %s baizi'%(name,count))
q.join()
print('realy make baizi.....')
count+=1
def Consumer(name):
count=0
while count < 10:
time.sleep(3) # 等待
# if not q.empty(): # 判断如果是空 那么就应该显示没有包子
# print('wait........')
# q.join() # 等待生产者发送包子作好的消息
# 消费者开始获取包子
data=q.get()
# 消费发送信息到队列中说包子已经开吃了, 生产者又继续开始制作下一个包子
q.task_done()
print('eat.....')
print('Consumer %s eat %s baizi'%(name,data))
# else:
# print('not baizi')
count+=1
P1=threading.Thread(target=Producer,args=('A'))
C1=threading.Thread(target=Consumer,args=('B'))
C2=threading.Thread(target=Consumer,args=('C'))
C3=threading.Thread(target=Consumer,args=('D'))
P1.start()
C1.start()
C3.start()
C2.start()10.7 多进程模块
多进程模块 multiprocessing
开启10进程以内可接受，原因python因为GIL一次只能运行一个线程，严重导致了多核CPU的使用
# 例一
# 导入多进程模块
import multiprocessing
import os
def Mympro(name):
print('name %s'%name)
print('master ppid: ',os.getppid())
print('slave pid: ',os.getpid())
if __name__ == '__main__':
p=multiprocessing.Process(target=Mympro,args=('xiong',)) # 严重注意的是： args传递参数需要有一个逗号 , 不然会报格式错误
p.start()
p.join()
# 结果
name xiong
master ppid: 7648 # 父进程id
slave pid: 7656 # 子进程id### 例二 继承
from multiprocessing import Process
import os
class Mympro(Process):
def __init__(self,name):
super(Mympro,self).__init__()
# Process().__init__(self)
self.name=name
def run(self):
print('name: ',self.name)
print('master ppid: ',os.getppid())
print('slave pid: ',os.getpid())
if __name__ == '__main__':
M=Mympro('xiong')
M.start()
M.join()
# 结果
name: xiong
master ppid: 3320
slave pid: 7516# 进程
实例方法：
run(): start()调用run方法
terminate(): 不管任务是否完成，立即停止工作过程
属性
daemon: 跟线程的setDaemon一样
进程间通信：
进程互相通信，共享通信 ，队列与管道只能实现数据交互，没有实现数据共享，manager可以用于数据之间共享
1、进程队列Queue
2、管道
3、manager
4、数据同步
5、进程池
# 进程队列
from multiprocessing import Process,Queue
# 继承多进程
class MultiP(Process):
def __init__(self,q):
super(MultiP,self).__init__()
self.q = q
# 重新构造run方法,start直接会调用这个
def run(self):
self.q.put('12321')
print('son id: ',id(self.q))
if __name__ == '__main__':
q=Queue() # 等于multiprocessing.Queue
# 创建的进程队列必须先传递到子进程,也就是先复制一份资源过去，然后才能进行其它的操作
M=MultiP(q)
M.start()
print('main id: ',id(q))
print('mian process: ',q.get())
# 结果
main id: 39167816
son id: 47022208
mian process: 123212、管道
from multiprocessing import Process,Pipe
# 驼峰的还是比较漂亮的
def MultiP(conn):
conn.send([123,{'12':'33'}])
data=conn.recv()
print(data)
print('son id: ',id(conn))
conn.close()
if __name__ == '__main__':
# 这个Pipe类似于socket的conn一样，前面是描述信息，后面是地址
# 这里创建的是两个对象，主一个，子一个用于进程间传递信息
main_conduit, son_conduit = Pipe()
M=Process(target=MultiP,args=(son_conduit,))
M.start()
print(main_conduit.recv())
main_conduit.send('11111') # 可以是字符串，列表，字典等
M.join()
print('main id: ', id(son_conduit))
# 结果
[123, {'12': '33'}]
11111
son id: 47170728
main id: 437191443、manager
from multiprocessing import Process,Manager
def MultiP(Li,Di,i):
Di['2']='2'
Di[i]='1'
Li.append(i)
lis=[]
if __name__ == '__main__':
# # manager=Manager()
with Manager() as manager:
Li=manager.list(range(5))
Di=manager.dict()
for i in range(5):
# 必须先将定义的manager的字典传递到进进程才能操作，类似浅拷贝
M=Process(target=MultiP,args=(Li,Di,i))
M.start()
lis.append(M)
for x in lis:
# 进程队列需要先运行子进程然后再运行父进程，否则会报错
x.join()
print(Di)
print(Li)
# 结果
{'2': '2', 0: '1', 1: '1', 2: '1', 4: '1', 3: '1'}
[0, 1, 2, 3, 4, 0, 1, 2, 4, 3]4、数据同步
当加了一把同步锁之后， 不管是进程还是线程 都是串行
from multiprocessing import Process,Lock
from time import sleep
def MultiP(lock,nums):
lock.acquire()
sleep(1)
print('main id: %s' %nums)
lock.release()
if __name__ == '__main__':
lock=Lock()
# 启动10个进程
li=[]
for i in range(10):
M=Process(target=MultiP,args=(lock,i))
M.start()
li.append(M)
for L in li:
L.join()
# 结果： 数据同步是同步方式，这是为了保证数据安全,类似tcp操作5、进程池
apply 同步
apply_async 异步
# 回调函数： 就是某个动作或者函数执行成功后，再去执行的函数
好处： 主进程直接调用回调函数，节省内存资源，如日志
回调函数接收的值来自于 子进程的 return值
from multiprocessing import Process,Pool
from time import sleep
import os
def Foo(nums):
sleep(1)
print('son process:',os.getpid())
print(nums)
return 'Foo: %s'%nums
# 这里的args接受的值来自于Foo函数的return值
def Pro(args):
print(args)
if __name__ == '__main__':
# 定义最大进程池，同时能打开多少个进程，默认是机器的CPU核数
pool=Pool(5)
for i in range(20):
# 异步进程池,callback回调函数,这里回调函数是由主线程运行的
pool.apply_async(func=Foo,args=(i,),callback=Pro)
# 这里的格式是固定的 close ， join
pool.close()
pool.join()
print('end')
# 打印结果： 每次五个 首先先打印子进程内容，然后再打印回调函数，依次执行完进程，最后打印end6、协程 协作式， 非抢占式
用户态： 通过用户自己进行操作的模式
协程主要解决的也是IO操作的时候
协程：本质上也是一个线程
协程的优势：
1、没有切换的消耗
2、没有锁的概念 （本身就是一个线程，遇到IO就切换）
缺点： 不能使用多核，(单线程) 但可以采用多进程+协程， 一个很好的解决并发的方案
python自带的yield
#### yield基础用法 例一：
def Yi():
print('ok')
while True:
x=yield
print(x)
y=Yi()
next(y)
y.send(1) # 发送一个值到yield x接受并打印，没有while就会直接打印出 StopIteration
#### 例二
def Yi():
print('ok')
while True:
x=yield
print('resv from Y2 value: %s'%x)
def Y2():
next(y)
n=0
while n<=4:
print('relay send Yi value %s'%(n))
y.send(n)
n+=2
if __name__ == '__main__':
y=Yi()
p=Y2()
# 结果
ok # 使用next打印生成器中的值
relay send Yi value 0 # send发送值到Y1,yield接收并赋值给x，然后打印
resv from Y2 value: 0 # 使用的是同一个线程，所以没有切换的损耗
relay send Yi value 2
resv from Y2 value: 2
relay send Yi value 4
resv from Y2 value: 4greenlet
switch() 启动 切换
缺点： 每一个需求都需要手动switch切换
py3.6没有这个模块了
gevent 重要
转载于:https://blog.51cto.com/xiong51/2062515
3873
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
