python-多进程&多线程

参考资料:https://www.liaoxuefeng.com/wiki/1016959663602400/1017628290184064

目录

1.多进程

1.1进程组成

1.2进程状态和转换

1.2.1使用Process方法创建进程

1.2.2使用继承方法创建进程

1.3进程通信

1.3.1共享存储

1.3.2消息传递

1.3.3管道通信

1.4进程同步和互斥

1.4.1进程同步

1.4.2进程互斥

1.4.3生产者消费者问题

1.4.4读者写者问题

1.4.5哲学家进餐问题

1.5多进程锁

1.5.1封锁协议

1.6进程池

2.多线程



1.多进程

想象一下,我办了一个工厂,专门生产中性笔,我请了一个工人,负责生产。这个工人先制造笔帽花了一个小时,再制造笔杆,也花了一个小时,但是只有一个工人,所以花了两个小时才组装一只中性笔。如果我雇佣了两个工人,同时进行笔帽和笔杆的生产,这时两个小时生产了两只中性笔。操作系统下面是计算机硬件,上面承载应用。支持多进程的操作系统,也就是多道操作系统,允许多个任务同时进行。好比我是双核的电脑,就对应于上面有两个工人,同时干活。单核电脑,也就是只有一个工人的情况下,能允许多个任务同时进行吗?答案是肯定的,我的一个工人可以1分钟制造笔帽,下一分钟制造笔杆……采用时间片流转的方式,去完成任务。

总结一下,

为什么需要多进程,是因为我们想要同时处理多个任务,也叫并发。

多进程是如何实现的,是把处理器的运行时间分成很小的时间片,当该时间片内该程序无法执行完毕,则暂停该任务,下一时间片内运行其它任务,如果操作系统中只有两个任务,则轮流执行。

这里可以看出来,实现多进程,必须有任务的启动,执行,暂停等。对应的就是就绪态-运行态-阻塞态相互转化。

多进程的作用,比如我们是单核处理器,进行计算任务的时候,也就是只调用CPU的计算资源,多进程效果不大,而且越多的进程,阻塞态和就绪态不停的切换,反而会比单线程执行的更慢,毕竟计算资源就那么多,你一起做完,还是1秒钟做这个,下一秒做那个,没有区别。多核处理器有倍数的提升。而当我们的任务更加复杂话,比如爬虫过程,我们通过http协议请求数据,分析处理数据,存储数据,这三个过程占用的资源各不一样,请求数据和处理数据,主要占用计算资源,也就是CPU,内存,存储数据,主要是IO过程,占用资源是磁盘。CPU和磁盘的速度是不一样的,可能计算时间是存储时间的1/10不到,可以考虑使用多线程,进行异步操作,当磁盘读写时,使CPU不至于闲置,进行充分利用。

还有一点,并发和并行的区别,并发指的是某一时间间隔内执行多个任务,精确到具体某一时间,只有一个任务在执行,

并行的话,具体某一时间,有多个任务在执行,也就是说并行一定是并发的。

最后说一下,什么是多进程,进程究竟是什么?

1.1进程组成

进程由程序段,数据段,PCB三部分组成,PCB中文名进程控制块,进程是系统资源分配调度的基本单位。通俗来说,就是程序的一次执行过程。

程序段:程序代码段

数据段:存储在内存中的数据

PCB:这里采用维基百科的解释

操作系统使用过程控制信息来管理过程本身。这包括:

  • 进程调度状态-进程的状态,如“就绪”,“挂起”等,以及其他调度信息,例如优先级值,自从进程获得CPU控制或自从获得控制以来经过的时间它被暂停了。同样,在流程暂停的情况下,必须为该流程正在等待的事件记录事件标识数据。
  • 流程结构信息–流程的子代ID,或以某种功能方式与当前流程相关的其他流程的ID,可以表示为队列,环或其他数据结构
  • 进程间通信信息–与独立进程之间的通信关联的标志,信号和消息
  • 进程特权-允许/禁止访问系统资源
  • 流程状态-新的,准备就绪,正在运行,正在等待,已失效
  • 进程号(PID)–每个进程的唯一标识号(也称为进程ID)
  • 程序计数器(PC)–指向要为此过程执行的下一条指令的地址的指针
  • CPU寄存器-寄存器集,需要在其中存储过程以在运行状态下执行
  • CPU调度信息-信息调度CPU时间
  • 内存管理信息–页表,内存限制,段表
  • 记帐信息- 用于进程执行的CPU数量,时间限制,执行ID等。
  • I / O状态信息-分配给进程的I / O设备列表。

内容有点多,我们简单一点,只需要记住进程描述信息pid和uid,一个PCB肯定包含进程标识符pid和用户标识符uid,不同的进程用pcb来区分,pcb上记录了pid,我们可以使用pid来区分不同的进程。

 

在讲解下面的代码的时候,还是再次强调一遍进程的状态转换,

1.2进程状态和转换

python-多进程&多线程_第1张图片

网上随便找的图

解释一下这五个词

创建:新建进程后,不会马上执行该进程,我们前面讲到了,进程由程序段,数据段,PCB三部分组成,创建过程中会申请空白pcb并写入信息,系统向该进程分配资源,接下来转入就绪态。打个比方,创建进程的过程就好比手机开机的过程,开机后才能打开APP,开机这个过程,创建了可以打开APP的“条件”

就绪:进程所占用的资源分两类,一个是处理机资源,一个是非处理机资源,当进程申请到除了处理机的所有其它资源,只要提供处理机,就可以执行程序,这种状态叫就绪态。同样就绪态提供了运行态的“条件”,运行态当然就是执行APP了。打个比方,好比我们考试,发卷子后不能答题,只能看题,我们看题的过程就拿到了非处理机资源,也就是知道怎么写了,就等着可以答题了,监考老师一声令下,马上答题,也就是就绪态到运行态,是因为我们拿到了处理机资源,手可以开始动了。

在分时操作系统中,我们按时间片去划分处理机资源,比如1秒为间隔,且只有两个进程,第一秒进程1运行,一秒过后,时间片用完了,第二秒要给进程2使用,第三秒又给进程1使用……当第一秒过去后,进程1还未执行完毕,则进程1要从运行态转为就绪态,等待下一个时间片,再转为运行态

运行:程序正在执行,对比上面的例子,就是手在书写答案

阻塞:进程执行过程中,由于未能成功申请非处理机资源,而主动由运行态转为阻塞态,等待资源,当资源可用的时候,再转为就绪态,当时间片流转过来的时候,再转为就绪态

退出:执行完毕,退出,系统回收PCB

 

讲的有点多,直接对着代码来说更直观一点,我们现在创建一个最简单进程

1.2.1使用Process方法创建进程

from multiprocessing import Process

def myProcess(name):
    print("正在执行的进程名称是", name)

if __name__ == "__main__":
    p = Process(target=myProcess, args=("进程1",))
    p.start()

结果如下

我们使用Process方法创建了一个进程,这个进程需要执行的内容由target指定,也就是方法myProcess。

p.start()方法启动一个进程,也就是从就绪态转为运行态

myProcess方法接收一个传入参数name,name的值由args指定,args接收一个元组,假如我们传入多个变量,可以这么写

from multiprocessing import Process

def myProcess(name1,name2):
    print("传入的第一个name是", name1)
    print("传入的第二个name是", name2)
if __name__ == "__main__":
    p = Process(target=myProcess, args=("进程1","进程2"))
    p.start()

效果如下

前面讲到的PID,我们也可以打印出来

from multiprocessing import Process
import os
def myProcess(*name):
    print("传入的name有:",name)
    print("os.getpid():",os.getpid())
if __name__ == "__main__":
    p = Process(target=myProcess, args=("进程1","进程2"))
    p.start()
    print("p.pid:",p.pid)

 结果如下

上面的myProcess方法传入参数是*name,表示可变参数,更加灵活

Process有一个方法叫join,可以阻塞其它线程,包括主线程,我们尝试一下

from multiprocessing import Process
import os
import time
def myProcess(name,s):
    print(name,"执行开始")
    time.sleep(s)#睡眠s秒
    print(name, "执行结束")
if __name__ == "__main__":
    p1 = Process(target=myProcess, args=("p1",1))
    p2 = Process(target=myProcess, args=("p2",0))
    p1.start()
    p2.start()

结果如下

python-多进程&多线程_第2张图片

我们创建了两个进程p1,p2,并先后启动,由于p1睡眠了一秒,导致p2执行完毕后,p1才执行完毕,我们能让p1执行完毕后再让p2执行么,我们试试join方法

from multiprocessing import Process
import os
import time
def myProcess(name,s):
    print(name,"执行开始")
    time.sleep(s)#睡眠s秒
    print(name, "执行结束")
if __name__ == "__main__":
    p1 = Process(target=myProcess, args=("p1",1))
    p2 = Process(target=myProcess, args=("p2",0))
    p1.start()
    p1.join()
    p2.start()

结果如下

python-多进程&多线程_第3张图片

p1.join()阻塞了所有其他进程

虽然看到的是只有两个进程p1,p2,但p1,p2实际上是运行在主进程下,我们可以分别打印出这个进程PID

from multiprocessing import Process
import os
import time
def myProcess(name,s):
    print(name,"执行开始")
    time.sleep(s)#睡眠s秒
    print(name, "执行结束")
if __name__ == "__main__":
    p1 = Process(target=myProcess, args=("p1",1))
    p2 = Process(target=myProcess, args=("p2",0))
    p1.start()
    p1.join()
    p2.start()
    #打印进程ID
    print("p1的pid是",p1.pid)
    print("p2的pid是",p2.pid)
    print("主进程的pid是",os.getpid())

python-多进程&多线程_第4张图片

 也就是说,p1.join()除了阻塞p2,还会阻塞主进程,我们看下一个例子

from multiprocessing import Process
import os
import time
def myProcess(name,s):
    print(name,"执行开始")
    time.sleep(s)#睡眠s秒
    print(name, "执行结束")
if __name__ == "__main__":
    p1 = Process(target=myProcess, args=("p1",1))
    p1.start()
    print("这正在执行主进程的内容")

 

python-多进程&多线程_第5张图片

如果按程序从上 到下的执行顺序,“这正在执行主进程的内容应该在最后出现,所以理解多进程,要抛弃这种观念,p1.start()将进程p1进入就绪态,其实已经脱离了这个主进程执行流,我这个界面的内容就是主进程,p1.start()相当于新开了一个执行界面,在这个执行界面执行p1进程定义的任务myProcess。由于进程p1睡眠了1秒,而主进程创建进程p1,将p1转为就绪态,打印信息“正在执行主进程”,肯定不需要1秒,所以就看到主进程的内容在代码后面出现,却在console界面先出现

红框内的代码,都是执行在主进程的内容,现在我们使用join阻塞主线程,打印结果将会是

p1执行开始,p1执行结束,正在执行主进程

代码如下

from multiprocessing import Process
import os
import time
def myProcess(name,s):
    print(name,"执行开始")
    time.sleep(s)#睡眠s秒
    print(name, "执行结束")
if __name__ == "__main__":
    p1 = Process(target=myProcess, args=("p1",1))
    p1.start()
    p1.join()
    print("这正在执行主进程的内容")

 

看看上图的执行顺序

直观对比一下,能更好认识join方法

 

1.2.2使用继承方法创建进程

from multiprocessing import Process
import os
import time
def myProcess(name,s):
    print(name,"执行开始")
    time.sleep(s)#睡眠s秒
    print(name, "执行结束")
class myProcessC(Process):
    def __init__(self,*name):
        super().__init__()
        self.name=name[0]
        self.s = name[1]
    def run(self):
        myProcess(self.name,self.s)
if __name__ == "__main__":
    p=myProcessC("进程p",1)
    p.start()
    p.join()
    print("这正在执行主进程的内容")

 

这里class myProcess继承自Process,__init__方法是构造方法,第一行是super().__init__()方法调用了Process的构造方法,

run()方法就是该进程需要执行的任务,这里调用了之前写的myPrcess方法

if__name__=="__main__",简单理解就是,假如我不加这段代码,该模块被其它模块导入时,会自动执行下面的四行代码。

1.3进程通信

进程之间不共享资源,进程通信有三种方式:共享存储,消息传递,管道通信

1.3.1共享存储

两个进程p1,p2,p1访问一个文件,往里面写数据,然后关闭文件,p2打开文件读数据,这样就能使数据从p1传递给p2。

这里的“文件"实际上是一个共享空间,是一种半双工通信

1.3.2消息传递

进程p1往消息缓冲区里写数据,进程 p2往消息缓存区读数据。缓冲区实际上是一个队列

我们可以使用multiprocessing.Queue队列实现消息传递,如下

from multiprocessing import Process, Queue
class ReadProcess(Process):
    def __init__(self, queue):
        self.queue = queue
        super().__init__()

    def run(self):
        while not self.queue.empty():
            result = self.queue.get()
            print("读入的数据是:", result)
            if result==10:
                exit()

class WriteProcess(Process):
    def __init__(self, queue):
        self.queue = queue
        super().__init__()
    def run(self):
        i = 0
        while not self.queue.full():
            i = i + 1
            self.queue.put(i)
            print("写入的数据是:", i)
            if i==10:
                exit()

if __name__ == "__main__":
    queue = Queue()
    w=ReadProcess(queue)
    r=WriteProcess(queue)
    r.start()
    w.start()

 

1.3.3管道通信

进程p1往管道写数据,进程p2往管道读数据管道不满,就可以一直写,管道不空,就可以一直读。管道实际上是一个文件

代码以后补

1.4进程同步和互斥

什么是进程同步,就是先做什么,再做什么,我得先穿好袜子,再穿鞋。

什么是互斥,就是上厕所,只有一个位置,我上厕所的时候,别人不能上。

要实现进程同步和互斥需要一个东西,叫信号量。

这里就不详细介绍信号量的实现方式了,我们只需要了解信号量有两个原语,P操作和V操作

P操作申请资源,V操作释放资源。

记录型信号量S初始为0,当调用P(S)时,S信号量会减一,此时S<0则进程会自我阻塞,放弃处理机,如果>=0则继续往下执行,

V(S)则会释放资源,将S加一,此时S仍旧小于等于0,则唤醒阻塞队列的进程。

伪代码如下:

P(S){
S=S-1
if(S<0)
{
将本进程加入到等待队列Q
阻塞本进程
}
}

V(S)
{
S=S+1
if(s<=0){
释放等待队列Q中的第一个进程
将该进程唤醒,也就是从阻塞态变成就绪态

}

上面出现得“资源”这个名词就是除了处理机之外得其它资源。进程占用的资源的两大类大类就是“资源”(除开处理机的资源)和处理机资源。

1.4.1进程同步

我们要做的同步操作,就是p1先执行,然后p2再执行

S=0
p1(){
穿袜子
V(S)
}
p2(){
P(S)
穿鞋子
}

这里有两个进程p1,p2,当我们start后,p1和p2同时进行,p2执行的时候,p(S)=p(0),S=0的时候,该进程会阻塞,所以p2进程就一直在等待。p1执行的时候,直接就把袜子穿好了,然后V(S)释放资源,这时S=1,,此时P2进程的P(S)=P(1),P2开始穿鞋子。达到了操作同步的效果。

代码如下:

 

from multiprocessing import Process,Semaphore
s = Semaphore(0)
class wearSocks(Process):
    def __init__(self):
        super().__init__()
    def run(self):
        global s
        print("穿袜子")#先执行操作
        s.release()
        print("p1:",s)
class wearShoes(Process):
    def __init__(self):
        super().__init__()
    def run(self):
        global s
        print("p2:",s)
        s.acquire()#先p
        print("穿鞋子")#后执行操作
if __name__ == '__main__':
    p1=wearSocks()
    p2=wearShoes()
    p1.start()
    p2.start()

 代码运行结果有误,所以只给出用法参考

搜到了一篇文章https://blog.csdn.net/hlg1995/article/details/81638732

说的是进程之间不共享变量,我以为只要声明了全局变量就可以共享,现在按照链接的例子,给出代码

import multiprocessing
import time
# 定义全局变量
my_list = list()
# 写入数据
def write_data():
    global my_list
    for i in range(5):
        my_list.append(i)
        time.sleep(0.2)
    print("write_data:", my_list)


# 读取数据
def read_data():
    global my_list
    print(my_list)


if __name__ == '__main__':
    # 创建写入数据的进程
    write_process = multiprocessing.Process(target=write_data)
    read_process = multiprocessing.Process(target=read_data)
    write_process.start()
    write_process.join()
    # 主进程等待写入进程执行完成以后代码 再继续往下执行
    read_process.start()
    read_process.join()

 还是回到之前的进程通信问题,使用Queue进行进程通信,代码如下

import multiprocessing
import time
q=multiprocessing.Queue()
def write_data(q):
    my_list = list()
    for i in range(5):
        my_list.append(i)
        time.sleep(0.2)
    q.put(my_list)
    print("write_data:", my_list)

def read_data(q):
    my_list=q.get()
    print("read_data:",my_list)

if __name__ == '__main__':
    write_process = multiprocessing.Process(target=write_data,args=(q,))
    read_process = multiprocessing.Process(target=read_data,args=(q,))
    write_process.start()
    write_process.join()
    read_process.start()
    read_process.join()

 所以我们不考虑全局变量的形式,除了消息传递,还有共享存储的方式进行消息传递。我们首先解决利用信号量实现进程同步的问题,也就是先穿袜子,再穿鞋子的问题。由于进程之间不能共享变量,我们试试把信号量变量存入队列中,看看是否可行

from multiprocessing import Process,Semaphore
import time
s = Semaphore(0)
class wearSocks(Process):
    def __init__(self):
        super().__init__()
    def run(self):
        #global s
        #print("穿袜子")#先执行操作
        #s.release()
        #print("p1:",s)
        time.sleep(2)
        print("穿袜子")
class wearShoes(Process):
    def __init__(self):
        super().__init__()
    def run(self):
        #global s
        #print("p2:",s)
        #s.acquire()#先p
        #print("穿鞋子")#后执行操作
        print("穿鞋子")
if __name__ == '__main__':
    p1=wearSocks()
    p2=wearShoes()
    p1.start()
    p2.start()

用信号量实现先穿袜子,再穿鞋子的,以及互斥关系,生产资消费者,读者写者问题,哲学家进餐问题,放到后面的线程去研究。

这里使用全局变量不行,如果我主动传入信号量是否可以

from multiprocessing import Process,Semaphore
import time
class wearSocks(Process):
    def __init__(self,s):
        super().__init__()
        self.s = s
    def run(self):
        time.sleep(3)
        self.s.release()
        print("穿袜子")
class wearShoes(Process):
    def __init__(self,s):
        super().__init__()
        self.s=s
    def run(self):
        self.s.acquire()#先p
        print("穿鞋子")
if __name__ == '__main__':
    s = Semaphore(0)
    p2=wearShoes(s)
    p2.start()
    p1 = wearSocks(s)
    p1.start()

结果

1.4.2进程互斥

我们不是使用文件,Queue,管道,也不使用全局变量,看看能不能通过传入信号量的方式实现互斥

伪代码如下:

S=1
p1(){
P(S)
打印100个1
V(S)
}
p2(){
v(S)
打印100个2
P(S)
}

进程同步就是先V后P,P1进程做完事情,释放资源后,P2进程P的时候才能获取资源,获取不到资源就会阻塞。

进程互斥就是用P和V夹,夹一下就表示互斥

我们先实现上面的代码

from multiprocessing import Process,Semaphore
import time
class wearSocks(Process):
    def __init__(self,s):
        super().__init__()
        self.s = s
    def run(self):
        self.s.acquire()
        for i in range(10):
            time.sleep(0.1)
            print("1")
        self.s.release()


class wearShoes(Process):
    def __init__(self,s):
        super().__init__()
        self.s=s
    def run(self):
        self.s.acquire()#先p
        for i in range(10):
            time.sleep(0.1)
            print("2")
        self.s.release()
if __name__ == '__main__':
    s = Semaphore(1)
    p2=wearShoes(s)
    p2.start()
    p1 = wearSocks(s)
    p1.start()

结果如下

python-多进程&多线程_第6张图片

循环次数改为10是不想等太久,各位可以尝试一下

那么我们如果取消这些互斥,会怎么样,代码如下

from multiprocessing import Process,Semaphore
import time
class wearSocks(Process):
    def __init__(self,s):
        super().__init__()
        self.s = s
    def run(self):
        #self.s.acquire()
        for i in range(10):
            time.sleep(0.1)
            print("1")
        #self.s.release()


class wearShoes(Process):
    def __init__(self,s):
        super().__init__()
        self.s=s
    def run(self):
        #self.s.acquire()#先p
        for i in range(10):
            time.sleep(0.1)
            print("2")
        #self.s.release()
if __name__ == '__main__':
    s = Semaphore(1)
    p2=wearShoes(s)
    p2.start()
    p1 = wearSocks(s)
    p1.start()

python-多进程&多线程_第7张图片

其实我有一个问题,这两个进程虽然靠全局变量无法通信,但是可以传入变量的方式进程通信,但是要是这两个进程运行在两个界面中,也就是两个代码文件中,要怎么传递变量呢?

1.4.3生产者消费者问题

若干(比如5个)生产者和10个消费者共享一个缓冲区,缓冲区作为临界资源,只能同时一个生产者或者一个消费者访问

缓冲区不满,则生产者写入数据,缓冲区不空,则消费者读入数据。

这里有两个同步关系,一个互斥关系,

生产者先生产,消费者后消费(同步)

消费者先创造空位,生产者后填补空位(同步)

生产和消费不能同时进行(互斥)

代码如下:

from multiprocessing import Process,Semaphore,Queue
import time
class producer(Process):
    def __init__(self,pro,com,s,name,productName,q):
        super().__init__()
        self.pro = pro
        self.com = com
        self.s = s
        self.name=name
        self.productName=productName
        self.q=q
    def run(self):
        while True:
            print(self.name,"生产了",self.productName)
            self.com.acquire()#只P不V的后做
            self.s.acquire()#p
            print(self.name,"填入缓冲区",self.productName)
            self.q.put(self.productName)
            self.s.release()#v 互斥
            self.pro.release()#只V不P的先做


class comsumer(Process):
    def __init__(self,pro,com,s,name,productName,q):
        super().__init__()
        self.pro = pro
        self.com = com
        self.s = s
        self.name = name
        self.productName = productName
        self.q=q
    def run(self):
        while True:
            self.pro.acquire()  # 只P不V的后做
            self.s.acquire()  # p
            productName=self.q.get()
            print(self.name, "从缓冲区拿出", productName)
            self.s.release()  # v 互斥
            self.com.release()  # 只V不P的先做
            print("消费了产品",productName)
if __name__ == '__main__':
    q=Queue()
    s = Semaphore(1)
    com=Semaphore(10)
    pro=Semaphore(0)
    for i in  range(5):
        producerName="生产者"+str(i)
        comsumerName="消费者"+str(i)
        productName="产品p"+str(i)
        p=producer(pro,com,s,producerName,productName,q)
        c =comsumer(pro,com,s,comsumerName,productName,q)
        p.start()
        c.start()

1.4.4读者写者问题

1.4.5哲学家进餐问题

1.5多进程锁

在数据库锁中,有读锁和写锁,也就是S锁(共享锁)X锁(排它锁),这两个锁的排列组合,又会出现下面三个封锁协议,虽然进程锁跟数据库锁可能不太一样,但是写出来供大家了解

1.5.1封锁协议

网上找了一张封锁相容矩阵

python-多进程&多线程_第8张图片

两句话:

加了X锁之后不能加任何锁,

加了S锁之后,只能加S锁

一级封锁协议:

在写之前必须加X锁,可以防止丢失修改;

丢失修改是这样,假如初始值是1,p1的操作是取数,乘以2,写回文件。p2的操作是取数,乘以3,写回文件。

p1进程先执行,取数的时候值为1,乘以2,写入2为2。p1写的过程中还未提交,p2就可以取数,仍旧取1,乘以3,写入3。最后结果是3,而不是6。

当加入一级封锁后,初始值为1,p1要修改数据,则加上X锁,这时出现两种情况,

(1).写入2并提交,这时释放X锁,p2取数后乘以2,将6写回文件

(2).还未写入2,所以X锁未释放,p2取数1,乘以3,准备将3写回文件,因为一级封锁协议,未申请到x锁,所以无法将3写入文件,等到p1释放x锁之后,p2在将3写入文件,这样看,好像加了x锁还是3,但是出现这种情况是因为p1未释放X锁的情况下,P2就进行了读操作,取出来了1,虽然跟下面不可重复读的例子有点差别,但是我认为这种情况也能称之为不可重复读,可以用二级封锁解决

二级封锁协议:

写之前加X锁,这是一级封锁的内容,在一级封锁的基础上,引入S锁,读之前加S锁,读完就释放,S锁和X锁满足封锁相容矩阵。

 

三级封锁协议:

在二级封锁的基础上,读之前加S锁,读完后不释放S锁,事务结束后再释放S锁。

仿照多线程Lock进行多进程锁代码如下(因为结果有误,所以只给出用法,仅供参考)

from multiprocessing import Lock,Process
shared_resource_with_no_lock = 0
shared_resource_with_lock=0
COUNT = 1000000
shared_resource_lock = Lock()

# 有锁的情况
def increment_with_lock():
    global shared_resource_with_lock
    for i in range(COUNT):
        shared_resource_lock.acquire()
        shared_resource_with_lock += 1
        shared_resource_lock.release()

def decrement_with_lock():
    global shared_resource_with_lock
    for i in range(COUNT):
        shared_resource_lock.acquire()
        shared_resource_with_lock -= 1
        shared_resource_lock.release()

# 没有锁的情况
def increment_without_lock():
    global shared_resource_with_no_lock
    for i in range(COUNT):
        shared_resource_with_no_lock += 1

def decrement_without_lock():
    global shared_resource_with_no_lock
    for i in range(COUNT):
        shared_resource_with_no_lock -= 1

if __name__ == "__main__":
    t1 = Process(target=increment_with_lock)
    t2 = Process(target=decrement_with_lock)
    t3 = Process(target=increment_without_lock)
    t4 = Process(target=decrement_without_lock)
    t1.start()
    t2.start()
    t3.start()
    t4.start()
    t1.join()
    t2.join()
    t3.join()
    t4.join()
    print ("the value of shared variable with lock management is %s" % shared_resource_with_lock)
    print ("the value of shared variable with race condition is %s" % shared_resource_with_no_lock)

所以核心还是不能共享变量造成的。

from multiprocessing import Process,Lock
import random
import time
import os
class write(Process):
    def __init__(self,lock,word):
        super().__init__()
        self.lock=lock
        self.word=word
    def run(self):
        #self.lock.acquire()
        for i in range(5):
            time.sleep(random.uniform(0,2))
            print(self.word)
        #self.lock.release()
if __name__=="__main__":
    lock=Lock()
    w1=write(lock,"1")
    w2=write(lock,"2")
    w3=write(lock,"3")
    w1.start()
    w2.start()
    w3.start()

我们想要的结果是5个相同的字符连续输出,上面的结果如下

python-多进程&多线程_第9张图片

现在加上lock

from multiprocessing import Process,Lock
import random
import time
import os
class write(Process):
    def __init__(self,lock,word):
        super().__init__()
        self.lock=lock
        self.word=word
    def run(self):
        self.lock.acquire()
        for i in range(5):
            time.sleep(random.uniform(0,2))
            print(self.word)
        self.lock.release()
if __name__=="__main__":
    lock=Lock()
    w1=write(lock,"1")
    w2=write(lock,"2")
    w3=write(lock,"3")
    w1.start()
    w2.start()
    w3.start()

python-多进程&多线程_第10张图片

这个锁有点类似X锁

进程中除了LOCK,还有RLOK,这里一段描述非常好, 我拿过来

如果你想让只有拿到锁的线程才能释放该锁,那么应该使用 RLock() 对象。和 Lock() 对象一样, RLock() 对象有两个方法: acquire() 和 release() 。当你需要在类外面保证线程安全,又要在类内使用同样方法的时候 RLock() 就很实用了。

(译者注:RLock原作解释的太模糊了,译者在此擅自添加一段。RLock其实叫做“Reentrant Lock”,就是可以重复进入的锁,也叫做“递归锁”。这种锁对比Lock有是三个特点:1. 谁拿到谁释放。如果线程A拿到锁,线程B无法释放这个锁,只有A可以释放;2. 同一线程可以多次拿到该锁,即可以acquire多次;3. acquire多少次就必须release多少次,只有最后一次release才能改变RLock的状态为unlocked)

来源:https://python-parallel-programmning-cookbook.readthedocs.io/zh_CN/latest/chapter2/07_Thread_synchronization_with_RLock.html

我们不花费太多时间在进程的信号量,lock,rlock上,在线程一章中我们再去去探究这三个东西

1.6进程池

搜到一篇文章写的不错,这里我就不写了

https://blog.csdn.net/brucewong0516/article/details/85788202

http://c.biancheng.net/view/2634.html

 

 

2.多线程

进程是占用计算资源(CPU)和非计算资源(内存,磁盘,网卡),来执行任务。当使用多进程去缩短执行时间时,涉及到进程切换,有较大的时空开销。那么我们把计算资源和非计算资源分散,非计算资源交给进程,计算资源交给进程下的线程,当线程切换时,不涉及到资源的占用和解除占用,开销较小。由于进程下的每一个线程都不占用非计算资源,也就是说他们共享这些资源,同一进程下,线程与线程之间可以很方便通信。(而不同的进程通信方式有管道通信,共享存储,消息传递等)。

如果要通俗理解,多进程就是多个人,一个人写数学作业,一个人写英语作业……。

多线程是,只有一个人,脑子同时思考数学和英语,但是手只能写一个作业,因此这一分钟写数学,下一分钟写英语。脑子就相当于非计算资源,手就相当计算资源,除非两只手都可以写作业,这就是并行,而不是并发了,所以并行效率会更高。

2.1创建线程

2.1.1函数创建

最简单的,我们创建5个线程,打印1,2,3,4,5,五个数

import threading
import time
import random
def printout(i):
    print(i)
def myThread(i):
    t=threading.Thread(name="打印数字"+str(i),target=printout,args=(i,))
    t.start()
    time.sleep(random.uniform(0,1))
if __name__=="__main__":
     for i in range(5):
         myThread(i)

或者换一种写法

import threading
import time
import random
def printout(i):
    print(i)
def myThread(i,l):
    t=threading.Thread(name="打印数字"+str(i),target=printout,args=(i,))
    l.append(t)
    time.sleep(random.uniform(0,1))
if __name__=="__main__":
     l=[]
     for i in range(5):
         myThread(i,l)
     for r in l:
         r.start()

结果很奇怪,感觉像同步了一样

python-多进程&多线程_第11张图片

我换成多进程写一下

import threading
import time
import random
from multiprocessing import Process
def printout(i):
    print(i)
def myThread(i):
    t=threading.Thread(name="打印数字"+str(i),target=printout,args=(i,))
    t.start()
    #time.sleep(random.uniform(1))
def myProcess(i):
    t=Process(target=printout,args=(i,))
    t.start()
    #time.sleep(random.uniform(0, 1))
if __name__=="__main__":
     for i in range(50):
         myThread(i)
         #myProcess(i)

怎么感觉多线程是同步的

是否同步后面解决,先留个坑

2.1.2继承方式创建线程

import threading
import time
import random
class MyThread(threading.Thread):
    def __init__(self,i):
        super().__init__()
        self.i=i
    def run(self):
        print(self.i)

if __name__=="__main__":
     for i in range(5):
         t=MyThread(i)
         t.start()

我们可以打印线程的名称

import threading
import time
import random
class MyThread(threading.Thread):
    def __init__(self,i):
        super().__init__()
        self.name="线程"+str(i)
        self.i=i
    def run(self):
        print(self.i)
        print(threading.currentThread().getName())
if __name__=="__main__":
     for i in range(5):
         t=MyThread(i)
         t.start()

2.3用多线程实现一个归并排序

当然我们也可以写一个快排

首先写一个不借助多线程写的一个归并排序

import time
def Merge(A,low,mid,high):
    B=A[low:high+1]
    i=low
    j=mid+1
    k=i
    while(i<=mid and j<=high):
        if B[i-low]<=B[j-low]:
            A[k]=B[i-low]
            i=i+1
        else:
            A[k]=B[j-low]
            j=j+1
        k=k+1
    if i<=mid:
        A[k:k+mid-i+1]=B[i-low:mid+1-low]
    if j<=high:
        A[k:k+high-j+1]=B[j-low:high+1-low]
def MergeSort(A,low,high):
    if(low

1百万居然要排60秒

我们用两个线程优化一下

import time
import threading
def Merge(A,low,mid,high):
    B=A[low:high+1]
    i=low
    j=mid+1
    k=i
    while(i<=mid and j<=high):
        if B[i-low]<=B[j-low]:
            A[k]=B[i-low]
            i=i+1
        else:
            A[k]=B[j-low]
            j=j+1
        k=k+1
    if i<=mid:
        A[k:k+mid-i+1]=B[i-low:mid+1-low]
    if j<=high:
        A[k:k+high-j+1]=B[j-low:high+1-low]
def MergeSort(A,low,high):
    if(low

 

居然是一点用都没有,大家可以搜索一下关键词“GIL”,能找到答案

python-多进程&多线程_第12张图片

那么线程在计算密集任务下效果不好,我们试试多进程有没有效果

import time
from multiprocessing import Process
def Merge(A,low,mid,high):
    B=A[low:high+1]
    i=low
    j=mid+1
    k=i
    while(i<=mid and j<=high):
        if B[i-low]<=B[j-low]:
            A[k]=B[i-low]
            i=i+1
        else:
            A[k]=B[j-low]
            j=j+1
        k=k+1
    if i<=mid:
        A[k:k+mid-i+1]=B[i-low:mid+1-low]
    if j<=high:
        A[k:k+high-j+1]=B[j-low:high+1-low]
def MergeSort(A,low,high):
    if(low

不是没有效果的问题,是根本得不出结果,暂时挖个坑吧,以后填这个坑

感兴趣的小伙伴如果能解决这个问题,可以在评论区给出答案

我个人猜测是不是要通过Queue传递这个数组

 

3协程

3.1什么是协程

这里直接给出别人的解释

https://www.liaoxuefeng.com/wiki/1016959663602400/1017968846697824

3.2如何创建协程

3.2.1生成器

def odd():
    yield 1
    yield 3
    yield 6
o = odd()
result=next(o)
print(result)
result=next(o)
print(result)
result=next(o)
print(result)
result=next(o)
print(result)

python-多进程&多线程_第13张图片

用 yield修饰的函数就是一个生成器,yield相当于return。

如果我们把odd的yield换成return,则该函数只会执行一次就退出。换成yield后,使用next()方法会执行到第一个yield,并返回值。直接返回1,执行第二次next()方法后,则从上次退出的地方继续执行。所以我们可以利用这个特性写一个计数器,比如我有10口罩,用完一次少一个,用完后提示需要再买口罩:

def getQuantity(n):
    while n>1:
        n = n - 1
        yield n
    yield("已用完,请重新购买")
q=getQuantity(10)
#拿出一个,还剩多少个
remaining=next(q)
print("拿一个剩余:",remaining)#打印剩下的口罩
#在拿一个
remaining=next(q)
print("再拿一个剩余:",remaining)#打印剩下的口罩
print("一次性拿完剩下所有的口罩")
for i in q:
    print(i)

python-多进程&多线程_第14张图片

未完待续……

 

你可能感兴趣的:(爬虫,python,多线程,多进程,processing,thread)