python------并发编程

一 操做系统的做用：

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

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

二 多道技术：

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

　　ps：

　　如今的主机通常是多核，那么每一个核都会利用多道技术

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

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

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

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

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

3、进程

　　进程：正在进行的一个过程或者说一个任务。而负责执行任务的则是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())

 

有两种状况：

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

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

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

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

二、开启多个子进程 

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），它会在未知的时间里建立线程，因此至于它是否是在主线程以前仍是以后启动都不能肯定。若是想要主线程在全部线程后等待，那么须要预先建立一个空列表，而后把全部启动的子线程放入列表中，对列表中的子线程整体进行循环阻塞后，启动主线程。

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

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()

View Code

锁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()

锁Lock

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

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()

 

 

4、并发与并行

　　不管是并行仍是并发，在用户看来都是'同时'运行的，不论是进程仍是线程，都只是一个任务而已，真是干活的是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共享同一个物理内存）

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

　　同步：就是在发出一个功能调用时，在没有获得结果以前，该调用就不会返回。按照这个定义，其实绝大多数函数都是同步调用。可是通常而言，咱们在说同步、异步的时候，特指那些须要其余部件协做或者须要必定时间完成的任务。

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

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

　　非阻塞：指在不能马上获得结果以前也会马上返回，同时该函数不会阻塞当前线程。

小结：

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

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