python------并发编程

一 操作系统的作用：

　　1：隐藏丑陋复杂的硬件接口，提供良好的抽象接口

　　2：管理、调度进程，并且将多个进程对硬件的竞争变得有序

二 多道技术：

　　1.产生背景：针对单核，实现并发

　　ps：

　　现在的主机一般是多核，那么每个核都会利用多道技术

　　有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个

　　cpu中的任意一个，具体由操作系统调度算法决定。

　　2.空间上的复用：如内存中同时有多道程序

　　3.时间上的复用：复用一个cpu的时间片

　　强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样 才能保证下次切换回来时，能基于上次切走的位置继续运行

三、进程

　　进程：正在进行的一个过程或者说一个任务。而负责执行任务的则是cpu

　　程序：仅仅只是一堆代码而已，而进程指的是程序的运行过程。

　　需要强调的是：同一个程序执行两次，那也是两个进程，比如打开暴风影音，虽然都是同一个软件，但是一个可以播放大话西游，一个可以播放海贼王。

关于multiprocess模块——综合的、多元的 进程模块（包）：python中创建进程用来替我做事。

 

import os
from multiprocessing import Process  #导入进程模块
import time
def func():
    time.sleep(2)
    print('子进程号%d'%os.getpid())


if __name__ =='__main__':
    p=Process(target=func)
    p.start()                                  #启动子进程
    print('第一次主进程号%d'%os.getpid())
    p.join()                                              #阻塞
    print('第二次主进程号%d'%os.getpid())

 

有两种情况：

　　1、没有p.join()  ：这种情况下不阻塞，执行主程序，调用子进程。子进程和父进程是异步执行。

创建进程对象 传要执行的函数 以及参数
进程对象.start()
主进程和子进程就是异步执行
如果主进程中的代码已经结束了，子进程还没结束，主进程会等待子进程

p.join 就是主进程会阻塞在join的位置，等待p进程结束
windows操作系统中 创建进程的语句一定要放在if __name__ == '__main__':条件语句下面

　　2、有p.join()：主进程阻塞在join的位置，等待p进程的结束（异步阻塞）

2、开启多个子进程 

import os
import time
from multiprocessing import Process
def func(i):
    time.sleep(3)
    print('%d :子进程%d干的事，父进程%d干的事'%(i,os.getpid(),os.getppid()))

if __name__=='__main__':
    p_lst=[]
    for i in range(10):
        p=Process(target=func,args=(i,))     #实例化，调用线程类，传参数
        p.start()                            #启动线程（类似传达一下消息
        p_lst.append(p) 
    for p in p_lst:
        p.join()                              #阻塞
    print('-------主进程-------')

　　创建一个线程，然后启动（对象名.start），它会在未知的时间里创建线程，所以至于它是不是在主线程之前还是之后启动都不能确定。如果想要主线程在所有线程后等待，那么需要预先创建一个空列表，然后把所有启动的子线程放入列表中，对列表中的子线程总体进行循环阻塞后，启动主线程。

3、另一种开启多进程的方法

import os
from multiprocessing import Process
class MyProcess(Process):  #必须创建一个类，必须继承Process方法
    def run(self):               #必须实现run方法
        print('子进程%d'%os.getpid())
        self.walk()
    def walk(self):
        print('子进程walk%d'%os.getpid())

if __name__ =='__main__':
    p=MyProcess()            #先实例化一个对象
    p.start()                   #启动子进程
    p.join()
    print('主进程%d'%os.getpid())  #主进程

4.守护进程

　　守护进程：守护进程会随着主进程的代码的结束而结束

　　守护进程的作用：会随着主进程的代码执行结束而结束，不会等待其他子进程

　　守护进程要在start之前设置，在守护进程（也是个子进程）中，不能再开启子进程。

import time
from multiprocessing import Process
def func():
    print('--'*10)
    time.sleep(15)
    print('--'*10)

def cal_time():
    while True:
        time.sleep(1)
        print('过去了1秒')

if __name__ == '__main__':
    p = Process(target=cal_time)
    p.daemon = True     # 一定在开启进程之前设置
    p.start()
    p2 = Process(target=func)  # 15s
    p2.start()
    for i in range(100):    # 10s
        time.sleep(0.1)
        print('*'*i)
    p2.join()

锁Lock：

　　在并发编程中，为了保证数据安全。加上锁之后，每次需要等待数据被访问完之后，才能继续被其他应用访问。

import json
import time
import random
from multiprocessing import Lock
from multiprocessing import Process

def search(i):
    with open('ticket') as f:
        print(i,json.load(f)['count'])

def get(i):
    with open('ticket') as f:
        ticket_num = json.load(f)['count']
    time.sleep(random.random())
    if ticket_num > 0:
        with open('ticket','w') as f:
            json.dump({'count':ticket_num-1},f)
        print('%s买到票了'%i)
    else:
        print('%s没票了'%i)

def task(i,lock):
    search(i)   # 查看票
    lock.acquire()                  #需要锁
    get(i)      # 抢票
    lock.release()               #释放锁

if __name__ == '__main__':
    lock = Lock()            #实例化锁
    for i in range(20):  # 20个人同时抢票
        p = Process(target=task,args=(i,lock))
        p.start()

信号量：一把钥匙多个锁，可以允许几个进程同时访问数据（数量是有限制的）

from multiprocessing import Semaphore
from multiprocessing import Process
import time
import random
def sing(i,sem):
    sem.acquire()
    print('%d进入KTV'%i)
    time.sleep(random.randint(1,10))
    print('%d离开ktv'%i)
    sem.release()

if __name__ =='__main__':
    sem=Semaphore(4)
    for i in range(20):
        Process(target=sing,args=(i,sem)).start()

 

 

四、并发与并行

　　无论是并行还是并发，在用户看来都是'同时'运行的，不管是进程还是线程，都只是一个任务而已，真是干活的是cpu，cpu来做这些任务，而一个cpu同一时刻只能执行一个任务

 　  1 并发：是伪并行，即看起来是同时运行。单个cpu+多道技术就可以实现并发，（并行也属于并发）

       2  并行：同时运行，只有具备多个cpu才能实现并行

 

  　 单核下，可以利用多道技术，多个核，每个核也都可以利用多道技术（多道技术是针对单核而言的）

 

      有四个核，六个任务，这样同一时间有四个任务被执行，假设分别被分配给了cpu1，cpu2，cpu3，cpu4，

 

      一旦任务1遇到I/O就被迫中断执行，此时任务5就拿到cpu1的时间片去执行，这就是单核下的多道技术

 

       而一旦任务1的I/O结束了，操作系统会重新调用它(需知进程的调度、分配给哪个cpu运行，由操作系统说了算)，可能被分配给四个cpu中的任意一个去执行

 

 

所有现代计算机经常会在同一时间做很多件事，一个用户的PC（无论是单cpu还是多cpu），都可以同时运行多个任务（一个任务可以理解为一个进程）。

 

　　启动一个进程来杀毒（360软件）

 

　　启动一个进程来看电影（暴风影音）

 

　　启动一个进程来聊天（腾讯QQ）

 

　　所有的这些进程都需被管理，于是一个支持多进程的多道程序系统是至关重要的

　　多道技术概念回顾：内存中同时存入多道（多个）程序，cpu从一个进程快速切换到另外一个，使每个进程各自运行几十或几百毫秒，这样，虽然在某一个瞬间，一个cpu只能执行一个任务，但在1秒内，cpu却可以运行多个进程，这就给人产生了并行的错觉，即伪并发，以此来区分多处理器操作系统的真正硬件并行（多个cpu共享同一个物理内存）

五、同步/异步和阻塞/非阻塞

　　同步：就是在发出一个功能调用时，在没有得到结果之前，该调用就不会返回。按照这个定义，其实绝大多数函数都是同步调用。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。

　　异步：当一个异步功能调用发出后，调用者不能立刻得到结果。当该异步功能完成后，通过状态、通知或回调来通知调用者。如果异步功能用状态来通知，那么调用者就需要每隔一定时间检查一次，效率就很低（有些初学多线程编程的人，总喜欢用一个循环去检查某个变量的值，这其实是一 种很严重的错误）。如果是使用通知的方式，效率则很高，因为异步功能几乎不需要做额外的操作。至于回调函数，其实和通知没太多区别。

　　阻塞：是指调用结果返回之前，当前线程会被挂起（如遇到io操作）。函数只有在得到结果之后才会将阻塞的线程激活。有人也许会把阻塞调用和同步调用等同起来，实际上他是不同的。对于同步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回而已。

　　非阻塞：指在不能立刻得到结果之前也会立刻返回，同时该函数不会阻塞当前线程。

小结：

　　1. 同步与异步针对的是函数/任务的调用方式：同步就是当一个进程发起一个函数（任务）调用的时候，一直等到函数（任务）完成，而进程继续处于激活状态。而异步情况下是当一个进程发起一个函数（任务）调用的时候，不会等函数返回，而是继续往下执行当，函数返回的时候通过状态、通知、事件等方式通知进程任务完成。

　　2. 阻塞与非阻塞针对的是进程或线程：阻塞是当请求不能满足的时候就将进程挂起，而非阻塞则不会阻塞当前进程