来自 计算机编程 2019-12-17 04:18 的文章
当前位置: 澳门威尼斯人平台 > 计算机编程 > 正文

python进阶——多进程

python多进程并发机制:

一.什么是进程

一、python并发编程之多进程

因为GIL(全局解释器锁)的限制(GIL是用来保证在任意时刻只能有一个控制线程在执行),所以python中的多线程并非真正的多线程。只有python程序是I/O密集型应用时,多线程才会对运行效率有显著提高(因在等待I/O的时,会释放GIL允许其他线程继续执行),而在计算密集型应用中,多线程并没有什么用处。考虑到要充分利用多核CPU的资源,允许python可以并行处理一些任务,这里就用到了python多进程编程了。multiprocessing是python中的多进程模块,使用这个模块可以方便地进行多进程应用程序开发。multiprocessing模块中提供了:Process、Pool、Queue、Manager等组件。

这里使用了multprocessing.Pool进程池,来动态增加进程

 进程是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。在早期面向进程设计的计算机结构中,进程是程序的基本执行实体;在当代面向线程设计的计算机结构中,进程是线程的容器。程序是指令、数据及其组织形式的描述,进程是程序的实体。我们自己在python文件中写了一些代码,这叫做程序,运行这个python文件的时候,这叫做进程。

1.1 multiprocessing模块介绍

  由于GIL的存在,python中的多线程其实并不是真正的多线程,如果想要充分地使用多核CPU的资源,在python中大部分情况需要使用多进程。

  multiprocessing包是Python中的多进程管理包。与threading.Thread类似,它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。

  该Process对象与Thread对象的用法相同,也有start(), run(), join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类 (这些对象可以像多线程那样,通过参数传递给各个进程),用以同步进程,其用法与threading包中的同名类一致。所以,multiprocessing的很大一部份与threading使用同一套API,只不过换到了多进程的情境。

 

构造方法:

Process([group [, target [, name [, args [, kwargs]]]]])

  group: 线程组,目前还没有实现,库引用中提示必须是None; 
  target: 要执行的方法; 
  name: 进程名; 
  args/kwargs: 要传入方法的参数。

实例方法:

  is_alive():返回进程是否在运行。

  join([timeout]):阻塞当前上下文环境的进程程,直到调用此方法的进程终止或到达指定的timeout(可选参数)。

  start():进程准备就绪,等待CPU调度

  run():strat()调用run方法,如果实例进程时未制定传入target,这star执行t默认run()方法。

  terminate():不管任务是否完成,立即停止工作进程

属性:

  daemon:和线程的setDeamon功能一样

  name:进程名字。

  pid:进程号。

 

方法介绍:

p1=Process(target=foo,args=('p1',))    开启子进程
p.start():启动进程,并调用该子进程中的p.run() 
p.run():进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法  

p.terminate():强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放,进而导致死锁
p.is_alive():如果p仍然运行,返回True

p.join([timeout]):主线程等待p终止(强调:是主线程处于等的状态,而p是处于运行的状态)。timeout是可选的超时时间,需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程

 

在linux中,主进程的全局变量,子进程能用

在window中,主进程的全局变量,子进程不能用能用

 

1.2 创建并开启子进程的两种方式

通过函数:

#函数方式
def foo(name):
    print('%s starting'%name)
    time.sleep(random.randrange(1,5))
    print('%s is end'%name)

if __name__ == '__main__':
    print('主进程starting')

    p1=Process(target=foo,args=('p1',))
    p2=Process(target=foo,args=('p2',))
    p3=Process(target=foo,args=('p3',))

    # p1.daemon = True
    # p2.daemon = True
    # p3.daemon = True

    p1.start()
    p2.start()
    p3.start()

    # p1.join()
    # p2.join()
    # p3.join()

    # time.sleep(1)
    print('主进程ending')

通过类的方式:

#用类的方式创建子进程
class MyProcess(Process):
    def __init__(self,name):
        super().__init__()
        # self.name=name

    def run(self):
        print('%s starting' % self.name)
        time.sleep(random.randrange(1, 5))
        print('%s id is %s' % (self.name,self.pid))
        print('%s is end'%self.name)

if __name__ == '__main__':
    print('主进程starting')
    for i in range(4):
        p = MyProcess(str(i))
        p.start()

    print('主进程ending')

1.3 Process对象的其他方法或属性

澳门威尼斯人平台 1澳门威尼斯人平台 2

#进程对象的其他方法一:terminate,is_alive
from multiprocessing import Process
import time
import random

class Piao(Process):
    def __init__(self,name):
        self.name=name
        super().__init__()

    def run(self):
        print('%s is piaoing' %self.name)
        time.sleep(random.randrange(1,5))
        print('%s is piao end' %self.name)


p1=Piao('egon1')
p1.start()

p1.terminate()#关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活
print(p1.is_alive()) #结果为True

print('开始')
print(p1.is_alive()) #结果为False

进程对象的其他方法一:terminate,is_alive

 

澳门威尼斯人平台 3澳门威尼斯人平台 4

#进程对象的其他方法二:p.daemon=True,p.join
from multiprocessing import Process
import time
import random

class Piao(Process):
    def __init__(self,name):
        self.name=name
        super().__init__()
    def run(self):
        print('%s is piaoing' %self.name)
        time.sleep(random.randrange(1,3))
        print('%s is piao end' %self.name)


p=Piao('egon')
p.daemon=True #一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程死,p跟着一起死
p.start()
p.join(0.0001) #等待p停止,等0.0001秒就不再等了
print('开始')

#进程对象的其他方法二:p.daemon=True,p.join

注:p.join(),是父进程在等p的结束,是父进程阻塞在原地,而p仍然在后台运行

澳门威尼斯人平台 5澳门威尼斯人平台 6

#进程对象的其他属性:name,pid
from multiprocessing import Process
import time
import random
class Piao(Process):
    def __init__(self,name):
        # self.name=name
        # super().__init__() #Process的__init__方法会执行self.name=Piao-1,
        #                    #所以加到这里,会覆盖我们的self.name=name

        #为我们开启的进程设置名字的做法
        super().__init__()
        self.name=name

    def run(self):
        print('%s is piaoing' %self.name)
        time.sleep(random.randrange(1,3))
        print('%s is piao end' %self.name)

p=Piao('egon')
p.start()
print('开始')
print(p.pid) #查看pid

#进程对象的其他属性:name,pid

1 Process类

#coding=utf-8
from multiprocessing import Pool
import time
def ft(x):
  #多任务,系统自动化配进程执行
  for i in range(2):
    print i,'-----------',x
    time.sleep(1)



def main_process():
    pool = Pool(processes=4) #控制进程池的大小,为4个进程
    for i in range(10):
        #添加入进程池,apply带_async,单独apply为阻塞版本;函数名target,参数args
        result = pool.apply_async(ft,(i,))

    pool.close()
    pool.join()

    if result.successful():
        print('_____success_____')


if __name__=="__main__":
    main_process()

 狭义定义:进程是正在运行的程序的实例(an instance of a computer program that is being executed)。 广义定义:进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元,在传统的操作系统中,进程既是基本的分配单元,也是基本的执行单元。 举例: 比如py1文件中有个变量a=1,py2文件中有个变量a=2,他们两个会冲突吗?不会的,是不是,因为两个文件运行起来后是两个进程,操作系统让他们在内存上隔离开,对吧。澳门威尼斯人平台 7澳门威尼斯人平台 8

1.2 进程间通讯 

1.1 构造方法

def __init__(self, group=None, target=None, name=None, args=(), kwargs={})

group:进程所属组,基本不用
target:进程调用对象(可以是一个函数名,也可以是一个可调用的对象(实现了__call__方法的类))
args:调用对象的位置参数元组
name:别名
kwargs:调用对象的关键字参数字典

运行结果:

 进程是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。在早期面向进程设计的计算机结构中,进程是程序的基本执行实体;在当代面向线程设计的计算机结构中,进程是线程的容器。程序是指令、数据及其组织形式的描述,进程是程序的实体。我们自己在python文件中写了一些代码,这叫做程序,运行这个python文件的时候,这叫做进程。  狭义定义:进程是正在运行的程序的实例(an instance of a computer program that is being executed)。  广义定义:进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元,在传统的操作系统中,进程既是基本的分配单元,也是基本的执行单元。  举例: 比如py1文件中有个变量a=1,py2文件中有个变量a=2,他们两个会冲突吗?不会的,是不是,因为两个文件运行起来后是两个进程,操作系统让他们在内存上隔离开,对吧。

1.2.1进程间通信(IPC)方式一:队列(推荐使用)

from multiprocessing import Process
import queue

def f(q,n):
    q.put(n*n+1)
    print("son process",id(q))

if __name__ == '__main__':

    q = queue.Queue()  
    print("main process",id(q))

    for i in range(3):
        p = Process(target=f, args=(q,i))
        p.start()

    print(q.get())
    print(q.get())
    print(q.get())

1.2 实例方法

is_alive():返回进程是否在运行
start():启动进程,等待CPU调度
join([timeout]):阻塞当前上下文环境,直到调用此方法的进程终止或者到达指定timeout
terminate():不管任务是否完成,立即停止该进程
run():start()调用该方法,当实例进程没有传入target参数,stat()将执行默认的run()方法

C:Python27python.exe D:/weixin/temp/testtmp.py
0 ----------- 0
0 ----------- 1
0 ----------- 2
0 ----------- 3
1 ----------- 0
1 ----------- 1
1 ----------- 2
1 ----------- 3
0 ----------- 4
0 ----------- 5
0 ----------- 6
0 ----------- 7
1 ----------- 4
1 ----------- 5
1 ----------- 6
1 ----------- 7
0 ----------- 8
0 ----------- 9
1 ----------- 8
1 ----------- 9
_____success_____

Process finished with exit code 0

进程的概念澳门威尼斯人平台 9澳门威尼斯人平台 10

1.2.2进程间通信(IPC)方式二:管道(不推荐使用,了解即可)

from multiprocessing import Pipe,Process

def foo(sk):
    sk.send("hello world")
    print(sk.recv())

if __name__ == '__main__':
    sock, conn = Pipe()
    p=Process(target=foo,args=(sock,))
    p.start()

    print(conn.recv())
    conn.send("hi son")

>>:hello world
       hi son

  Pipe()返回的两个连接对象代表管道的两端。 每个连接对象都有send()和recv()方法(等等)。 请注意,如果两个进程(或线程)尝试同时读取或写入管道的同一端,管道中的数据可能会损坏。

1.3 属性

authkey
daemon:守护进程标识,在start()调用之前可以对其进行修改
exitcode:进程的退出状态码
name:进程名
pid:进程id

从以上运行结果可以看出,一次最多执行了我们设定的4个进程。

动态性:进程的实质是程序在多道程序系统中的一次执行过程,进程是动态产生,动态消亡的。并发性:任何进程都可以同其他进程一起并发执行独立性:进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位;异步性:由于进程间的相互制约,使进程具有执行的间断性,即进程按各自独立的、不可预知的速度向前推进结构特征:进程由程序、数据和进程控制块三部分组成。多个不同的进程可以包含相同的程序:一个程序在不同的数据集里就构成不同的进程,能得到不同的结果;但是执行过程中,程序不能发生改变。

1.2.3进程间通信方式三:共享数据(不推荐使用,了解即可)

  Queue和pipe只是实现了数据交互,并没实现数据共享,即一个进程去更改另一个进程的数据。可以通过Manager实现数据共享,

  从数据安全角度看,进程间通信应该尽量避免使用本节所讲的共享数据的方式

用manager实现进程共享数据

from multiprocessing import Process,Manager

def foo(d,l,i):
    d[i] = i
    d['egon'] = 'egon'
    l.append(i**2)

if __name__ == '__main__':
    # manager = Manager()
    dic = Manager().dict()
    Mlist = Manager().list([11,22,33])
    l=[]
    for i in range(5):
        p=Process(target=foo,args=(dic,Mlist,i))
        p.start()
        l.append(p)

    for j in l:
        j.join()

    print(dic)
    print(Mlist)

1.4 实例

实例一:传入的target为一个函数

#!/usr/bin/python
#coding=utf-8

import time
import random
from multiprocessing import Process

def foo(i):
    print time.ctime(), "process the %d begin ......" %i
    time.sleep(random.uniform(1,3))
    print time.ctime(), "process the %d end !!!!!!" %i

if __name__ == "__main__":
    print time.ctime(), "process begin......"

    p_lst = list()
    for i in range(4):
        p_lst.append(Process(target=foo, args=(i,)))    #创建4个子进程
    #启动子进程
    for p in p_lst:
        p.start()
    #等待子进程全部结束
    for p in p_lst:
        p.join()

    print time.ctime(), "process end!!!!!"   

实例二:传入的target为一个可调用对象

#!/usr/bin/python
#coding=utf-8

import time
import random
from multiprocessing import Process

class Foo(object):
    def __init__(self, i):
        self.i = i

    def __call__(self):
        '''
        使Foo的实例对象成为可调用对象
        '''                                                                                                        
        print time.ctime(), "process the %d begin ......" %self.i
        time.sleep(random.uniform(1,3))
        print time.ctime(), "process the %d end !!!!!!" %self.i

if __name__ == "__main__":
    print time.ctime(), "process begin......"

    p_lst = list()
    for i in range(4):
        p_lst.append(Process(target=Foo(i)))    #创建4个子进程
    #启动子进程
    for p in p_lst:
        p.start()
    #等待子进程全部结束
    for p in p_lst:
        p.join()

    print time.ctime(), "process end!!!!!"

实例三:派生Process子类,并创建子类的实例

#!/usr/bin/python                                                                                                  
#coding=utf-8

import time
import random
from multiprocessing import Process

class MyProcess(Process):

    def __init__(self, i):
        Process.__init__(self)
        self.i = i

    def run(self):
        '''
        #重写run方法,当调用start方法时,就会调用当前重写的run方法中的程序
        '''
        print time.ctime(), "process the %d begin ......" %self.i
        time.sleep(random.uniform(1,3))
        print time.ctime(), "process the %d end !!!!!!" %self.i

if __name__ == "__main__":
    print time.ctime(), "process begin......"

    p_lst = list()
    for i in range(4):
        p_lst.append(MyProcess(i))  #创建4个子进程
    #启动子进程
    for p in p_lst:
        p.start()
    #等待子进程全部结束
    for p in p_lst:
        p.join()

    print time.ctime(), "process end!!!!!"

 

进程的特征澳门威尼斯人平台 11澳门威尼斯人平台 12

1.3 进程池(重点学习)

  开多进程的目的是为了并发,如果有多核,通常有几个核就开几个进程,进程开启过多,效率反而会下降(开启进程是需要占用系统资源的,而且开启多余核数目的进程也无法做到并行),但很明显需要并发执行的任务要远大于核数,这时我们就可以通过维护一个进程池来控制进程数目,比如httpd的进程模式,规定最小进程数和最大进程数...

  进程池(Pool)可以提供指定数量的进程,供用户调用,当有新的请求提交到pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到规定最大值,那么该请求就会等待,直到池中有进程结束,就重用进程池中的进程

    在利用Python进行系统管理的时候,特别是同时操作多个文件目录,或者远程控制多台主机,并行操作可以节约大量的时间。

进程池实例:

from multiprocessing import Pool
import time

def foo(n):
    print(n)
    time.sleep(1)

if __name__ == '__main__':

    pool_obj=Pool(5)

    for i in range(100):
        pool_obj.apply_async(func=foo,args=(i,))

    pool_obj.close()
    pool_obj.join()

    print("ending")

  

 

2 Pool类

当使用Process类管理非常多(几十上百个)的进程时,就会显得比较繁琐,这是就可以使用Pool(进程池)来对进程进行统一管理。当池中进程已满时,有新进程请求执行时,就会被阻塞,直到池中有进程执行结束,新的进程请求才会被放入池中并执行。

 

程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。而进程是程序在处理机上的一次执行过程,它是一个动态的概念。程序可以作为一种软件资料长期存在,而进程是有一定生命期的。程序是永久的,进程是暂时的。举例:就像qq一样,qq是我们安装在自己电脑上的客户端程序,其实就是一堆的代码文件,我们不运行qq,那么他就是一堆代码程序,当我们运行qq的时候,这些代码运行起来,就成为一个进程了。

2.1 构造方法

def __init__(self, processes=None, initializer=None, initargs=(),                 maxtasksperchild=None)

processes:池中可容纳的工作进程数量,默认情况使用os.cpu_count()返回的数值,一般默认即可
其他参数暂不清楚有什么用处......

Linux and python学习交流1,2群已满.

进程与程序的区别

2.2 实例方法

apply(self, func, args=(), kwds={}):阻塞型进程池,会阻塞主进程,直到工作进程全部退出,一般不用这个
apply_async(self, func, args=(), kwds={}, callback=None):非阻塞型进程池
map(self, func, iterable, chunksize=None):与内置map行为一致,它会阻塞主进程,直到map运行结束
map_async(self, func, iterable, chunksize=None, callback=None):非阻塞版本的map
close():关闭进程池,不在接受新任务
terminate():结束工作进程
join():阻塞主进程等待子进程退出,该方法必须在close或terminate之后执行

Linux and python学习交流3群新开,欢迎加入,一起学习.qq 3群:563227894

注意:同一个程序执行两次,就会在操作系统中出现两个进程,所以我们可以同时运行一个软件,分别做不同的事情也不会混乱。比如打开暴风影音,虽然都是同一个软件,但是一个可以播放米老鼠,一个可以播放唐老鸭。澳门威尼斯人平台,**

2.3 实例

#!/usr/bin/python
#coding=utf-8

import time
import random
from multiprocessing import Pool

def foo(i):
    print time.ctime(), "process the %d begin ......" %i
    time.sleep(random.uniform(1,3))
    print time.ctime(), "process the %d end !!!!!!" %i

if __name__ == "__main__":

    print time.ctime(), "process begin......"
    pool = Pool(processes = 2)  #设置进程池中最大并行工作进程数为2                                                 
    for i in range(4):
        pool.apply_async(foo, args=(i,))    #提交4个子进程任务

    pool.close()
    pool.join()

    print time.ctime(), "process end!!!!!"

结果:

Fri Nov 18 13:57:22 2016 process begin......
Fri Nov 18 13:57:22 2016 process the 0 begin ......
Fri Nov 18 13:57:22 2016 process the 1 begin ......
Fri Nov 18 13:57:23 2016 process the 1 end !!!!!!
Fri Nov 18 13:57:23 2016 process the 2 begin ......
Fri Nov 18 13:57:24 2016 process the 0 end !!!!!!
Fri Nov 18 13:57:24 2016 process the 3 begin ......
Fri Nov 18 13:57:25 2016 process the 2 end !!!!!!
Fri Nov 18 13:57:25 2016 process the 3 end !!!!!!
Fri Nov 18 13:57:25 2016 process end!!!!!

不前进,不倒退,停止的状态是没有的.

二.并发和并发

3 Queue类

Queue主要提供进程间通信以及共享数据等功能。除Queue外还可以使用Pipes实现进程间通信(Pipes是两个进程间进行通信)

一起进步,与君共勉,

通过进程之间的调度,也就是进程之间的切换,我们用户感知到的好像是两个视频文件同时在播放,或者音乐和游戏同时在进行,那就让我们来看一下什么叫做并发和并行

3.1 构造方法

def __init__(self, maxsize=0)

maxsize:用于设置队列最大长度,当为maxsize<=0时,队列的最大长度会被设置为一个非常大的值(我的系统中队列最大长度被设置为2147483647)

 

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

3.2 实例方法

put(self, obj, block=True, timeout=None)

1、block为True,若队列已满,并且timeout为正值,该方法会阻塞timeout指定的时间,直到队列中有出现剩余空间,如果超时,会抛出Queue.Full异常
2、block为False,若队列已满,立即抛出Queue.Full异常

get(self, block=True, timeout=None)

block为True,若队列为空,并且timeout为正值,该方法会阻塞timeout指定的时间,直到队列中有出现新的数据,如果超时,会抛出Queue.Empty异常
block为False,若队列为空,立即抛出Queue.Empty异常

  并发:是伪并行,即看起来是同时运行。单个cpu+多道技术就可以实现并发,

3.3 实例

#!/usr/bin/python
#coding=utf-8

import time
import random
from multiprocessing import Process, Queue

def write(q):
    for value in "abcd":
        print time.ctime(), "put %s to queue" %value
        q.put(value)
        time.sleep(random.random())

def read(q):
    while True:
        value = q.get()
        print time.ctime(), "get %s from queue" %value

if __name__ == "__main__":
    #主进程创建Queue,并作为参数传递给子进程
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    #启动子进程pw,往Queue中写入
    pw.start()
    #启动子进程pr,从Queue中读取
    pr.start()
    #等待写进程执行结束
    pw.join()
    #终止读取进程                                                                                                  
    pr.terminate()

运行结果:

Fri Nov 18 15:04:13 2016 put a to queue
Fri Nov 18 15:04:13 2016 get a from queue
Fri Nov 18 15:04:13 2016 put b to queue
Fri Nov 18 15:04:13 2016 get b from queue
Fri Nov 18 15:04:13 2016 put c to queue
Fri Nov 18 15:04:13 2016 get c from queue
Fri Nov 18 15:04:13 2016 put d to queue
Fri Nov 18 15:04:13 2016 get d from queue

澳门威尼斯人平台 13澳门威尼斯人平台 14

4 Manager类

Manager是进程间数据共享的高级接口。
Manager()返回的manager对象控制了一个server进程,此进程包含的python对象可以被其他的进程通过proxies来访问。从而达到多进程间数据通信且安全。Manager支持的类型有list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Queue, Value和Array。
如下是使用Manager管理一个用于多进程共享的dict数据

#!/usr/bin/python
#coding=utf-8

import time
import random
from multiprocessing import Manager, Pool

def worker(d, key, value):
    print time.ctime(), "insert the k-v pair to dict begin: {%d: %d}" %(key, value)
    time.sleep(random.uniform(1,2))
    d[key] = value  #访问共享数据
    print time.ctime(), "insert the k-v pair to dict end: {%d: %d}" %(key, value)


if __name__ == "__main__":
    print time.ctime(), "process for manager begin"
    mgr = Manager()
    d = mgr.dict()
    pool = Pool(processes=4)                                                                                       
    for i in range(10):
        pool.apply_async(worker, args=(d, i, i*i))

    pool.close()
    pool.join()
    print "Result:"
    print d
    print time.ctime(), "process for manager end"

运行结果

Fri Nov 18 16:36:19 2016 process for manager begin
Fri Nov 18 16:36:19 2016 insert the k-v pair to dict begin: {0: 0}
Fri Nov 18 16:36:19 2016 insert the k-v pair to dict begin: {1: 1}
Fri Nov 18 16:36:19 2016 insert the k-v pair to dict begin: {2: 4}
Fri Nov 18 16:36:19 2016 insert the k-v pair to dict begin: {3: 9}
Fri Nov 18 16:36:20 2016 insert the k-v pair to dict end: {3: 9}
Fri Nov 18 16:36:20 2016 insert the k-v pair to dict begin: {4: 16}
Fri Nov 18 16:36:20 2016 insert the k-v pair to dict end: {0: 0}
Fri Nov 18 16:36:20 2016 insert the k-v pair to dict begin: {5: 25}
Fri Nov 18 16:36:21 2016 insert the k-v pair to dict end: {2: 4}
Fri Nov 18 16:36:21 2016 insert the k-v pair to dict begin: {6: 36}
Fri Nov 18 16:36:21 2016 insert the k-v pair to dict end: {1: 1}
Fri Nov 18 16:36:21 2016 insert the k-v pair to dict begin: {7: 49}
Fri Nov 18 16:36:21 2016 insert the k-v pair to dict end: {5: 25}
Fri Nov 18 16:36:21 2016 insert the k-v pair to dict begin: {8: 64}
Fri Nov 18 16:36:22 2016 insert the k-v pair to dict end: {4: 16}
Fri Nov 18 16:36:22 2016 insert the k-v pair to dict begin: {9: 81}
Fri Nov 18 16:36:23 2016 insert the k-v pair to dict end: {8: 64}
Fri Nov 18 16:36:23 2016 insert the k-v pair to dict end: {6: 36}
Fri Nov 18 16:36:23 2016 insert the k-v pair to dict end: {7: 49}
Fri Nov 18 16:36:23 2016 insert the k-v pair to dict end: {9: 81}
Result:
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
Fri Nov 18 16:36:23 2016 process for manager end
你是一个cpu,你同时谈了三个女朋友,每一个都可以是一个恋爱任务,你被这三个任务共享要玩出并发恋爱的效果,应该是你先跟女友1去看电影,看了一会说:不好,我要拉肚子,然后跑去跟第二个女友吃饭,吃了一会说:那啥,我去趟洗手间,然后跑去跟女友3开了个房,然后在你的基友眼里,你就在和三个女友同时在一起玩。

单核cpu多进程并发举例

  并行:并行:同时运行,只有具备多个cpu才能实现并行

澳门威尼斯人平台 15澳门威尼斯人平台 16

将多个cpu必须成高速公路上的多个车道,进程就好比每个车道上行驶的车辆,并行就是说,大家在自己的车道上行驶,会不影响,同时在开车。这就是并行

多个cpu多个进程举例三.同步异步阻塞非阻塞1.进程状态澳门威尼斯人平台 17

在了解其他概念之前,我们首先要了解进程的几个状态。在程序运行的过程中,由于被操作系统的调度算法控制,程序会进入几个状态:就绪,运行和阻塞。

本文由澳门威尼斯人平台发布于计算机编程,转载请注明出处:python进阶——多进程

关键词: