并发编程---进程

一,背景知识

进程即正在执行的一个过程。进程是对正在运行程序的一个抽象。

进程的概念起源于操作系统，是操作系统最核心的概念，也是操作系统提供的最古老也是最重要的抽象概念之一。操作系统的其他所有内容都是围绕进程的概念展开的。

所以想要真正了解进程，必须事先了解操作系统，点击进入    

PS：即使可以利用的cpu只有一个（早期的计算机确实如此），也能保证支持（伪）并发的能力。将一个单独的cpu变成多个虚拟的cpu（多道技术：

时间多路复用和空间多路复用+硬件上支持隔离），没有进程的抽象，现代计算机将不复存在。

理论基础

#一 操作系统的作用：
    1：隐藏丑陋复杂的硬件接口，提供良好的抽象接口
    2：管理、调度进程，并且将多个进程对硬件的竞争变得有序

#二 多道技术：
    1.产生背景：针对单核，实现并发
    ps：
    现在的主机一般是多核，那么每个核都会利用多道技术
    有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个
    cpu中的任意一个，具体由操作系统调度算法决定。
    
    2.空间上的复用：如内存中同时有多道程序
    3.时间上的复用：复用一个cpu的时间片
       强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样
            才能保证下次切换回来时，能基于上次切走的位置继续运行

二,进程

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

1,并发与并行

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

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

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

  

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

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

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

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

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

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

 进程间的数据不会共享

data_list = []

def task(arg):
    data_list.append(arg)
    print(data_list)


def run():
    for i in range(5):
        p = Process(target=task,args=(i,))
        p.start()

if __name__ == '__main__':
    run()

打印结果

[0]
[4]
[2]
[1]
[3]

通过类创建进程

# 通过继承类来创建进程
class Myprocess(Process):

    def run(self):
        print(f"当前进程{multiprocessing.current_process()}")


if __name__ == '__main__':
    for i in range(4):
        p = Myprocess()
        p.start()

如果要启动大量的子进程，可以用进程池的方式批量创建子进程：

from multiprocessing import Pool
import os

def func(i):
    print(f"进程{i} id>>>{os.getpid()}")


if __name__ == '__main__':
    p = Pool(5)
    for i in range(6):
        p.apply_async(func, args=(i,))
    p.close()
    p.join()  # join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。

　　 print("end")

进程间通信

Process之间肯定是需要通信的，操作系统提供了很多机制来实现进程间的通信。Python的multiprocessing模块包装了底层的机制，提供了Queue、Pipes等多种方式来交换数据。

 我们以Queue为例，在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据：

from multiprocessing import Process, Queue
import os,time,random

# 写数据进程执行的代码
def write(q):
    print("Process to write: %s" % os.getpid())
    for value in ['A',"B",'C']:
        print(f"Put {value} to queue...")
        q.put(value)
        time.sleep(random.random())


# 读数据进程执行代码
def read(q):
    print(f"Process to read: {os.getpid()}")
    while 1:
      value = q.get(1)
      print(f'Get {value} from queue.')


if __name__ == '__main__':
    # 父进程创建Queue,并传给各个子进程
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 启动子进程write，写入
    pw.start()
    # 启动子进程pr读取
    pr.start()
    # 等待pw的结果
    pw.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    pr.terminate()

Manager进程间数据共享

from multiprocessing import Process, Manager

def task(arg, dic):
    time.sleep(0.5)
    dic[arg] = 100


if __name__ == '__main__':
    m = Manager()
    dic = m.dict()

    process_list = []
    for i in range(10):
        p = Process(target=task, args=(i, dic,))
        p.start()
        # p.join()
        process_list.append(p)

    while True:
        count = 0
        for p in process_list:
            if not p.is_alive():  # is_alive 看进程是否还存活着
                count += 1
        if count == len(process_list):
            break
    print(dic)

# ##################### 进程间的数据通信，其他电脑 #####################
def task(url, dic):
    '''
    假设写了个爬虫，爬取的数据url对应的数据
    :param url: 
    :param dic: 
    :return: 
    '''
    dic[url] = "res..."
    pass

if __name__ == '__main__':
    while True:
        # 连接上指定的服务器
        # 去机器上获取url
        url = 'adfasdf'
        p = Process(target=task, args=(url,))
        p.start()

进程锁

进程锁与线程锁的用法一模一样

为什么要加锁，用到锁是因为数据共享，数据不安全，而进程默认是数据隔离的；当不同的进程用到相同的数据时（进程间通信，数据共享），才用到进程锁。

线程加锁是因为同一进程下的多线程数据是共享的，线程不安全(多个线程改同一个变量把内容改乱了)，加锁是为了线程安全。

import multiprocessing
import time

lock = multiprocessing.Lock()


def task(arg):
    print("进程来了")
    lock.acquire()
    time.sleep(2)      
    print(arg)
    lock.release()

if __name__ == '__main__':
    p1 = multiprocessing.Process(target=task, args=(1,))
    p1.start()
    p2 = multiprocessing.Process(target=task, args=(2,))
    p2.start()