并发编程
一.操作系统
1.计算机的硬件组成:
主板: 固化（寄存器，是直接和cpu进行交互的一个硬件）
CPU: 中央处理器：计算（数字计算和逻辑计算）和控制（控制所有硬件协调工作）
存储 : 硬盘，内存
输入设备: 键盘，鼠标，话筒
输出设备: 显示器，音箱，打印机
2.计算机的发展史:
第一代计算机：电子管计算机，及其耗电，体积庞大，散热量特别高
第二代计算机：晶体管计算机，
第三代计算机：白色大头计算机，集成电路计算机，一个板子固化几十到上百个小硬件
第四代计算机：大型集成电路计算机，一个板子可以达到固化十万个硬件
第五代计算机：甚大型集成电路计算机
3.计算机的操作系统
定义:操作系统是一个软件，是一个能直接操纵硬件的一个软件。
目标:无论什么时候，操作系统的目标总是：让用户用起来更加的轻松。高可用，低耦合
dos系统 纯编程系统 单用户单任务？
windows系统 单用户多任务(早期windows)
unix系统 多用户多任务
操作系统的作用:
1，封装所有硬件接口，让各种用户使用电脑更加轻松
2，是对计算机内所有资源进行合理的调度和分配
4.语言的发展史:
计算机识别的是二进制，
机器语言，由1 和 0组成代码
汇编语言，指令形式, add n,m move n,m
高级语言：面向过程语言（C），面向对象语言（C++，JAVA，python，.net,php）
二.进程
1.进程概念:是指正在进行的程序
组成: 代码段，数据段，PCB(进程管理控制)
进程的三大基本状态:
就绪状态：已经获得运行需要的所有资源，除了CPU
执行状态：已经获得了所有资源包括cpu，处于正在运行
阻塞状态：因为各种原因，进程放弃了cpu，导致进程无法继续执行，此时进程处于内存中，继续等待获取cpu
进程的一个特殊状态：
挂起状态：是指因为种原因，进程放弃了cpu，导致进程无法继续执行，此时进程被踢出内存。
2.六个名词:
并行 ： 两个进程在同一时间点发生
并发 ： 两个进程在同一时间间隔内运行
同步 ： 某一个任务的执行必须依赖于另一个任务的返回结果
异步 ： 某一个任务的执行，不需要依赖于另一个任务的返回，只需要告诉另一个任务一声
阻塞 ： 程序因为类似于IO等待、等待事件等导致无法继续执行。
非阻塞：程序遇到类似于IO操作时，不再阻塞等待，如果没有及时的处理IO，就报错或者跳过等其他操作
3.进程的两种开启方法:
(1) p = Process(target=None,args(,))
from multiprocessing import Process import time import os def func(i): time.sleep(1) print('这里是儿子进程,儿子自己的pid是%s,儿子的父进程的pid是%s'%(os.getpid(),os.getppid())) # os.getpid()获取的是当前进程自己的pid # os.getppid()获取的是当前进程的父进程的pid if __name__ == '__main__': p = Process(target=func,args=(1,))# 实例化一个进程对象 p.start()# 开启一个子进程 print('这里是父亲进程，父进程自己的pid是：%s,父亲的父亲的pid是%s'%(os.getpid(),os.getppid()))
结果:
这里是父亲进程，父进程自己的pid是：12220,父亲的父亲的pid是840
这里是儿子进程,儿子自己的pid是12328,儿子的父进程的pid是12220
(2) 自定义类，继承Process父类
from multiprocessing import Process import time import os class MyProcess(Process): def __init__(self): super(MyProcess, self).__init__() def run(self): print('这是以继承类的方式开启的子进程') if __name__ == '__main__': p1 = MyProcess() p1.start()# 是指，解释器告诉操作系统，去帮我开启一个进程， 就绪状态 p1.run()# 告诉操作系统，现在马上帮我执行这个子进程 执行
结果:
这是以继承类的方式开启的子进程
这是以继承类的方式开启的子进程
(3)进程的常用方法
（1） start() 开启一个子进程
（2） join() 异步变同步（就是让父进程停留在join这句话，等待子进程执行结束，父进程再继续执行）
from multiprocessing import Process import time def func(): for i in range(10): time.sleep(0.01) print('儿子在这里') if __name__ == '__main__': p = Process(target=func) p.start() p.join()# 是让主进程等待子进程执行完。 现象：主进程执行到这句话，主进程阻塞住，等待子进程执行 # time.sleep(1) for i in range(2): time.sleep(0.01) print('爸爸在这里') # 开启一个正常的子进程，父进程会等待子进程结束后，父进程也就是程序才结束 # p.join()# 是让主进程等待子进程执行完。 现象：主进程执行到这句话，主进程阻塞住，等待子进程执行 # 如何把父进程和子进程之间的关系变为同步或者异步？ # 父进程执行join，就会变成同步，不执行join，父进程和子进程就是异步的关系 # join必须放在start()后边 结果: 儿子在这里 儿子在这里 儿子在这里 儿子在这里 儿子在这里 儿子在这里 儿子在这里 儿子在这里 儿子在这里 儿子在这里 爸爸在这里 爸爸在这里
（3） is_alive() 判断进程是否活着
（4） terminate() 杀死进程
from multiprocessing import Process import time def func(): time.sleep(1) print(123) if __name__ == '__main__': p = Process(target=func,) p.start() p.terminate()# 杀死p进程,让解释器告诉操作系统，请杀掉p进程。 print('子进程是否还活着？', p.is_alive()) time.sleep(0.002) print('子进程是否还活着？', p.is_alive()) # 返回一个bool值，如果返回True，代表进程还活着,如果返回False，代表子进程死了 # p.is_alive() 判断p进程是否还活着 # p.terminate() 杀死p进程 结果: 子进程是否还活着？ True 子进程是否还活着？ False
(4) 进程的常用属性
from multiprocessing import Process import time import os def func(): print('这里是儿子,儿子的pid是%s'%(os.getpid())) if __name__ == '__main__': p = Process(target=func) p.start() p.name = 'alex' print('儿子的名字是%s'%p.name) print('儿子的pid是%s'%p.pid) print('儿子是不是守护进程？',p.daemon) 结果: 儿子的名字是alex 儿子的pid是14260 儿子是不是守护进程？ False 这里是儿子,儿子的pid是14260
(5)守护进程
守护进程：跟随着父进程的代码执行结束，守护进程就结束
特点:
随着父进程的代码执行完毕才结束
守护进程不能创建子进程
守护进程必须要在start之前设置
from multiprocessing import Process import time def func(): time.sleep(100) print('这里是儿子哦') if __name__ == '__main__': p = Process(target=func) p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置 p.start() time.sleep(1) print('这是爸爸')
三.进程间通信
1.学习锁机制:
l = Lock()
一把锁配一把钥匙
拿钥匙，锁门 l.acquire()
还钥匙，开门 l.release()
#模拟12306抢票 from multiprocessing import Process,Lock import time def check(i): with open('余票') as f: con = f.read() print('第%s个人查到余票还剩%s张'%(i,con)) def buy_ticket(i,l): l.acquire()# 拿钥匙，锁门 with open('余票') as f: con = int(f.read()) time.sleep(0.1) if con > 0: print('\033[31m 第%s个人买到票了\033[0m'%i) con -= 1 else: print('\033[32m 第%s个人没有买到票\033[0m'%i) time.sleep(0.1)# 是指 买完票后，把余票数量重写写入数据库的时间延迟 with open('余票','w') as f: f.write(str(con)) l.release()# 还钥匙，开门 if __name__ == '__main__': l = Lock() for i in range(10): p_ch = Process(target=check,args=(i+1,)) p_ch.start() for i in range(10): p_buy = Process(target=buy_ticket,args=(i+1,l)) p_buy.start() 结果: 第3个人查到余票还剩3张 第4个人查到余票还剩3张 第2个人查到余票还剩3张 第1个人查到余票还剩3张 第5个人查到余票还剩3张 第7个人查到余票还剩3张 第8个人查到余票还剩3张 第6个人查到余票还剩3张 第9个人查到余票还剩3张 第10个人查到余票还剩3张 第3个人买到票了 第2个人买到票了 第1个人买到票了 第4个人没有买到票 第5个人没有买到票 第7个人没有买到票 第10个人没有买到票 第6个人没有买到票 第9个人没有买到票 第8个人没有买到票
锁机制:
from multiprocessing import Lock l = Lock() l.acquire()# 拿走钥匙，锁门，不让其他人进屋 l.release()# 释放锁。 还钥匙，开门，允许其他人进屋
存钱问题:
from multiprocessing import Process,Value,Lock import time def get_money(num,l):# 取钱 l.acquire()# 拿走钥匙，锁上门，不允许其他人进屋 for i in range(100): num.value -= 1 print(num.value) time.sleep(0.01) l.release()# 还钥匙，打开门，允许其他人进屋 def put_money(num,l):# 存钱 l.acquire() for i in range(100): num.value += 1 print(num.value) time.sleep(0.01) l.release() if __name__ == '__main__': num = Value('i',100) l = Lock() p = Process(target=get_money,args=(num,l)) p.start() p1 = Process(target=put_money, args=(num,l)) p1.start() p.join() p1.join() print(num.value)
2.学习信号机制
sem = Semaphore(n)
n : 是指初始化一把锁配几把钥匙，一个int型
拿钥匙，锁门 l.acquire()
还钥匙，开门 l.release()
信号量机制比锁机制多了一个计数器，这个计数器是用来记录当前剩余几把钥匙的。
当计数器为0时，表示没有钥匙了，此时acquire()处于阻塞。
对于计数器来说，每acquire一次，计数器内部就减1，release一次，计数器就加1
from multiprocessing import Process,Semaphore import time import random def func(i,sem): sem.acquire() print('第%s个人进入小黑屋,拿了钥匙锁上门' % i) time.sleep(random.randint(3,5)) print('第%s个人出去小黑屋,还了钥匙打开门' % i) sem.release() if __name__ == '__main__': sem = Semaphore(5)# 初始化了一把锁5把钥匙，也就是说允许5个人同时进入小黑屋 # 之后其他人必须等待，等有人从小黑屋出来，还了钥匙，才能允许后边的人进入 for i in range(20): p = Process(target=func,args=(i,sem,)) p.start()
from multiprocessing import Semaphore,Lock l = Lock() l.acquire() print(123) l.release() l.acquire() print(456) # l.release() l.acquire() print(678)
3.学习事件机制
e = Event() # e.set() #将is_set()设为True # e.clear() # 将is_set()设为False # e.wait() #判断is_set的bool值，如果bool为True，则非阻塞，bool值为False，则阻塞 # e.is_set() # 标识 # 事件是通过is_set()的bool值，去标识e.wait() 的阻塞状态 # 当is_set()的bool值为False时，e.wait()是阻塞状态 # 当is_set()的bool值为True时，e.wait()是非阻塞状态 # 当使用set()时，是把is_set的bool变为True # 当使用clear()时，是把is_set的bool变为False
from multiprocessing import Process,Event import time import random def tra(e): '''信号灯函数''' # e.set() # print('\033[32m 绿灯亮! \033[0m') while 1:# 红绿灯得一直亮着，要么是红灯要么是绿灯 if e.is_set():# True,代表绿灯亮,那么此时代表可以过车 time.sleep(5)# 所以在这让灯等5秒钟，这段时间让车过 print('\033[31m 红灯亮! \033[0m')# 绿灯亮了5秒后应该提示到红灯亮 e.clear()# 把is_set设置为False else: time.sleep(5)# 此时代表红灯亮了，此时应该红灯亮5秒，在此等5秒 print('\033[32m 绿灯亮! \033[0m')# 红的亮够5秒后，该绿灯亮了 e.set()# 将is_set设置为True def Car(i,e): e.wait()# 车等在红绿灯，此时要看是红灯还是绿灯，如果is_set为True就是绿灯，此时可以过车 print('第%s辆车过去了'%i) if __name__ == '__main__': e = Event() triff_light = Process(target=tra,args=(e,))# 信号灯的进程 triff_light.start() for i in range(50):# 描述50辆车的进程 if i % 3 == 0: time.sleep(2) car = Process(target=Car,args=(i+1,e,)) car.start()
