数学建模社区-数学中国

标题: 爬虫（七十）多进程multiprocess（六十一） [打印本页]

---

作者: 杨利霞    时间: 2020-5-31 10:35
标题: 爬虫（七十）多进程multiprocess（六十一）

爬虫（七十）多进程multiprocess（六十一）
& H& F; J; V5 i: d

Python中的multiprocess提供了Process类，实现进程相关的功能。但是它基于fork机制，因此不被windows平台支持。想要在windows中运行，必须使用if __name__ == '__main__:的方式，显然这只能用于调试和学习，不能用于实际环境。

另外，在multiprocess中你既可以import大写的Process，也可以import小写的process，这两者是完全不同的东西。这种情况在Python中很多，请一定要小心和注意。

下面是一个简单的多进程例子，Process类的用法和Thread类几乎一模一样。

• 
  
  import os
  
  
• 
  
  import multiprocessing
  
  " E3 B+ d( w" ~4 ]
• 
  
  2 z& Z, n; O2 L2 x8 y. h$ ~
  
  : C& \, T: I8 {  G# B8 ]
• 
  
  def foo(i):
  
  7 M% i4 {  x, T, r3 y# q0 i
• 
  / t. i( a1 V' [% D4 C
  0 ^& n" m. F7 x7 Z  C0 }    # 同样的参数传递方法
  
  
• 
  
      print("这里是 ", multiprocessing.current_process().name)
  
  
• 
  
  6 O1 m& \) t- K! `8 K    print('模块名称:', __name__)
  
  2 R; n& [# _3 [9 T* Q! c
• 
  
      print('父进程 id:', os.getppid())  # 获取父进程id
  4 ^. W0 u' ]$ y5 {5 D! X2 J9 @% k
  ( i6 v0 n/ `: A3 e; b- l; Q' p
• 
  9 U$ }4 x6 P2 S! C
      print('当前子进程 id:', os.getpid())  # 获取自己的进程id
  
  8 g7 s( Z" b: H: I% U. C
• 
  / c. q% v( U7 S4 x
  2 \; n& z4 A' r+ I5 l    print('------------------------')
  
  
• 
  
  
  
  : d9 K, h) g( R: a! W# [! }
• 
  ! k; [, t, I  o5 ]7 m- U% o% H7 [
  if __name__ == '__main__':
  
  " X. r* k5 D, L8 [0 e
• 
  % ?1 z" }) ^& Y, A
  
  
  
• 
  
      for i in range(5):
  
  / ]( _4 O4 }9 y+ o% c
• 
  . J8 Y% T- [1 S6 U' P
  ) w/ x/ l4 y- T. P! V9 M! d2 _        p = multiprocessing.Process(target=foo, args=(i,))
  
  
• 
  
          p.start()
  # q/ C: L5 S7 l# O- F+ B6 e
  $ K3 \9 T* J% x1 s. R* j
  

运行结果：

• 
  4 B+ C' T! W9 `3 A, [  V- Q$ n
  ! n  M4 L7 C' x. H- X1 e9 t! G这里是  Process-2
  
  $ P8 a& Q+ z# z; D2 n" w
• 
  
  * D! Y- [2 ~8 H  L  }模块名称: __mp_main__
  
  
• 
  9 N7 _: z  j$ m! Z$ ~
  6 R/ `8 `1 n4 ]1 H# {父进程 id: 880
  
  
• 
  ' I) n# l! H* R6 z3 B  x& o$ S7 u
  当前子进程 id: 5260
  4 m& w8 U. _2 J/ U; W
  
• 
  6 d9 l6 U5 Q) C* }
  0 `& \/ C9 T$ I, F--------------
  
  
• 
  
  这里是  Process-3
  
  
• 
  
  模块名称: __mp_main__
  
  # p3 J8 Q; J" q8 d+ U+ K/ f* C
• 
  " m( O! W" I. G" ^/ z. I( A
  父进程 id: 880
  : @6 A- O4 V2 i
  1 i# U4 U2 _8 R  R4 V* A, V  D
• 
  & l8 l' v3 g% \9 H9 `
  当前子进程 id: 4912
  
  
• 
  
  --------------
  4 w- P6 K- O% g; M
  : l* @6 F8 F) O$ S3 d/ F
• 
  " f5 Y) w6 N4 l! }
  这里是  Process-4
    \2 |: [2 l5 s
  
• 
  - D) o; x0 R/ q. B; A
  模块名称: __mp_main__
  
  
• 
  
  父进程 id: 880
  
  
• 
    X! ^9 m, w6 [. t0 h; ~
  当前子进程 id: 5176
  " n* _% s1 e; j6 F. m; Z
  + B8 T" }* F) n9 [
• 
  . |5 ^5 H' J  Z6 o& w
  --------------
  0 s& S3 E" E0 H$ u
  ; w8 l; c) m+ \& p' H
• 
  
  这里是  Process-1
  
  - @. X% b$ S; @2 G0 e8 E
• 
  " `0 R3 P$ Q+ X* v
  , x* I. \( a7 E4 C; K模块名称: __mp_main__
  / [7 A" n% J0 S. D/ r
  * j7 z, H2 Q! m- \6 J5 C
• 
  
  父进程 id: 880
  % J! O* H6 G0 c4 E
  / P& P/ ]# y& p/ ?" i
• 
  
  当前子进程 id: 5380
  7 f! }0 A8 @: ^; o! {/ _3 f7 o
  4 l" c# h  q& U: g, p' B& ~; ~  L" n
• 
  : H8 Z3 J8 g( v4 O4 S! h+ x
  4 j& I, B9 H8 L. H+ K--------------
  
  . U/ g! R0 f1 i* v% e: `' N- y2 J
• 
  
  - D6 @/ D* i5 w( H这里是  Process-5
  
  6 C4 k/ \7 k& j& u+ k8 S* e
• 
  5 x% l' w! @+ H2 _, T, A' R
  模块名称: __mp_main__
  
  3 e5 U6 t3 J" O# d% Q0 R+ k
• 
  ; S# [' r4 ^3 E+ G0 ~
  父进程 id: 880
  3 l  Z$ c/ _' o. }! b
  
• 
  
  3 {4 \( n8 k# x/ v当前子进程 id: 3520
  
  
• 
  
  ( T: O; z/ q4 ^  K" Y* e! K/ I--------------
  - O. x. ?# ~) ~! x
  
  . M/ S" a. V& O; Q0 W: g8 m

1. 进程间的数据共享

在Linux中，每个子进程的数据都是由父进程提供的，每启动一个子进程就从父进程克隆一份数据。

创建一个进程需要非常大的开销，每个进程都有自己独立的数据空间，不同进程之间通常是不能共享数据的，要想共享数据，一般通过中间件来实现。

下面我们尝试用一个全局列表来实现进程间的数据共享：

• 
  
  ! S0 E9 b" s7 l' {/ nfrom multiprocessing import Process
  
  ) v9 \9 u( ~6 z; t) }3 _( w$ j
• 
  4 `3 b1 f2 d9 V  H
  
  # S: H6 s8 ~6 B3 p; s: E
  
• 
  / t; C9 v3 d; B! C/ b. D" o9 \! \
  lis = []
  
  
• 
  3 V( u5 G/ ^. P  i
  
  
  
• 
  ' X$ R  G/ Y9 F
  def foo(i):
  ( k; P9 z2 t+ @2 y1 M9 p
  3 L( I+ ]- p: V* i, ]" _. K9 B& B
• 
  
      lis.append(i)
  
  
• 
  ; w  [* S, P: |* F
      print("This is Process ", i," and lis is ", lis, " and lis.address is  ", id(lis))
  
  
• 
  
  - o1 H9 ~8 `+ e3 b" Z; D" m
  3 }) v0 G* _) q
  8 c( h( b/ s; S+ N, F! q( y+ f
• 
  $ b7 }, C- @1 a  n! H/ d0 W6 K2 C5 z
  4 u5 O' S: i9 @if __name__ == '__main__':
  
  
• 
  
  5 M5 q5 A- O1 {0 J- V( s    for i in range(5):
  $ b( ^3 U1 {+ G" u+ B" y
  9 g3 g( p% p# I5 k' D9 R
• 
  
    a0 t1 M) r- O8 a$ A        p = Process(target=foo, args=(i,))
  ! H( X6 S) U& `7 E" s
  
• 
    L1 j* R  H8 F7 ?' R" w+ x7 a4 c
  6 j' N- E+ S7 D/ ], Y- t        p.start()
  1 I4 i9 ~' B& d+ C
  5 m0 I3 I3 J; k
• 
  
  ( N( L: O+ R2 P, t- `0 T    print("The end of list_1:", lis)
  
  # X2 V2 ]6 o' B4 I  X
  ( i2 e- g5 v' q0 F

运行结果：

• 
  
  The end of list_1: []
  , `2 V; t; t/ }7 j& z
  
• 
  * p1 U% d# T6 d' j6 s. O1 t: s- o
  This is Process  2  and lis is  [2]  and lis.address is   40356744
  5 ]: e9 c( w$ i( h
  
• 
    O8 ?  H3 c% i" `( h
  This is Process  1  and lis is  [1]  and lis.address is   40291208
  
  " G& D+ C$ _2 Y4 ^! \. K
• 
  
  6 V6 p- q0 g8 o! CThis is Process  0  and lis is  [0]  and lis.address is   40291208
  " E9 ~( `2 G. d+ t1 W
  ! f" D  v$ Y' A. H1 O) A6 [
• 
    G6 r6 W' T% y
  This is Process  3  and lis is  [3]  and lis.address is   40225672
  
  ! c: V, a( X, s5 Y! W6 M
• 
  
  This is Process  4  and lis is  [4]  and lis.address is   40291208
  
  6 e7 f7 a/ f1 I/ O3 g
  

可以看到，全局列表lis没有起到任何作用，在主进程和子进程中，lis指向内存中不同的列表。

想要在进程之间进行数据共享可以使用Queues、Array和Manager这三个multiprocess模块提供的类。

1.1 使用Array共享数据

对于Array数组类，括号内的“i”表示它内部的元素全部是int类型，而不是指字符“i”，数组内的元素可以预先指定，也可以只指定数组的长度。Array类在实例化的时候必须指定数组的数据类型和数组的大小，类似temp = Array('i', 5)。对于数据类型有下面的对应关系：

• 
  
  'c': ctypes.c_char, 'u': ctypes.c_wchar,
  2 y0 _# v! ?8 R8 E+ o
  4 j0 U) A- b: O
• 
  
  0 M; {% |: ]0 g  S- C'b': ctypes.c_byte, 'B': ctypes.c_ubyte,
  & D. Y* {" P0 G: W) f4 i
  : u" d9 h3 G  X6 B
• 
  * t9 F7 \* Y" K! x1 |6 l8 a
  ! W  q! P( ^' w0 f' i, M' n" a'h': ctypes.c_short, 'H': ctypes.c_ushort,
  
  
• 
  
  'i': ctypes.c_int, 'I': ctypes.c_uint,
  
  + A; G) e$ q+ e8 }1 d8 C* Q
• 
  & K8 \7 k/ k# o0 M% m
  'l': ctypes.c_long, 'L': ctypes.c_ulong,
  
  
• 
  
  'f': ctypes.c_float, 'd': ctypes.c_double
  
  
  

看下面的例子：

• 
  
  from multiprocessing import Process
  % Z! Y1 r# S" H# p; e) y
  / y0 w4 \1 f: r) r
• 
  2 W4 _; N1 k! p6 X
  from multiprocessing import Array
  1 b. t2 Q1 ~0 ^, q3 [& @
  ; Y& U' O0 d4 j7 }
• 
  
  
  
  
• 
  
  $ @5 {6 a/ Y) G9 O9 `def func(i,temp):
  
  % ?5 Q3 ]2 w, ^5 c
• 
  
  ) i0 V5 |3 _9 F7 V1 Q    temp[0] += 100
  
  % q6 h: Y+ @# t; o1 T) a
• 
  - \, O* |: g% _+ k% F4 c8 g
      print("进程%s " % i, ' 修改数组第一个元素后----->', temp[0])
  ) ?0 |% o) `& r4 X
  * {  f8 C2 N8 K& E) I2 j
• 
  
  
  : {9 ]! J8 B, |
  
• 
  5 G3 F3 B9 D& ^+ R  ]' B
  if __name__ == '__main__':
  
  
• 
  ' g( @3 w/ |, p: i% i
  . ~2 m  I; z; \* W6 A1 _    temp = Array('i', [1, 2, 3, 4])
  
  
• 
  
  ; o+ ?6 L& v+ _0 b    for i in range(10):
  ( |, X; Q+ S7 S$ v4 a
  
• 
  2 ]7 q% z8 r5 O  s
          p = Process(target=func, args=(i, temp))
  % l" W' {  T7 d! i* o; @1 N
  
• 
  6 j# h: C0 g" Q
          p.start()
  - j* b4 e7 e- G
  + A7 ]( k3 Q( F0 T; q) m
  $ m, r# e7 s/ c2 ~3 X- Z8 d

运行结果：

• 
  
  进程2   修改数组第一个元素后-----> 101
  ( D4 U( T8 e. d7 I
  
• 
  $ C  [; q5 r4 r( O
  3 O; f5 M, R# k  Q" m4 |6 ^进程4   修改数组第一个元素后-----> 201
  # H6 U% b) m$ [' @+ D4 Z) ]3 ^9 O( A+ v
  ) n8 c0 a) k- G
• 
  1 W+ W4 A: Q9 c9 }: N
  进程5   修改数组第一个元素后-----> 301
  
  
• 
  
  进程3   修改数组第一个元素后-----> 401
  % H9 O* U3 F4 h2 N( V" i6 j3 s
  
• 
  / e- b: H- o' m  ~; K
  4 p7 j5 U: M1 C% z9 Q; u1 V# a进程1   修改数组第一个元素后-----> 501
  
  0 B- r: G7 l+ f8 l9 U4 N8 Q4 }' Y, u- o
• 
  9 T, l2 Q; v% ^1 K& k
  进程6   修改数组第一个元素后-----> 601
  1 q% v/ L% j! r9 L7 V& r. Z/ K
  
• 
  9 p; ~+ _/ e: @
  进程9   修改数组第一个元素后-----> 701
  # |& y/ z& S: D2 R  i7 k$ L2 c: A
  
• 
  
  进程8   修改数组第一个元素后-----> 801
  
  # Y: F' ]1 c/ s" l. }
• 
  
  , m. ?* W! Y! u$ u  D8 I进程0   修改数组第一个元素后-----> 901
  
  
• 
  
  & r7 N( q3 k& N0 s5 G8 j进程7   修改数组第一个元素后-----> 1001
  6 \* U) [/ ]5 Z. ]* z! Q" p
  
  6 b3 x+ ~2 H1 P8 t; f' I/ x/ ~

1.2 使用Manager共享数据

通过Manager类也可以实现进程间数据的共享。Manager()返回的manager对象提供一个服务进程，使得其他进程可以通过代理的方式操作Python对象。manager对象支持 list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value ,Array等多种格式。

• 
  
  ( ~6 d) G( _. {( C7 V0 Zfrom multiprocessing import Process
  
  
• 
  . M8 d7 i# d3 R9 B3 w! H$ @
  from multiprocessing import Manager
  0 j" N5 B- A7 F' I. C. j
  
• 
  # K  c. q. M( d8 _
  3 L* Q$ p- K* f% o3 y' O: n
  
  $ q  U! F; n+ S5 U
• 
  * h  n3 @# ?! u1 }% b9 |" p
  : F* d4 @, J6 H9 K4 ?& Tdef func(i, dic):
  ! Y( W8 L; `9 P2 \" L' l% m
  # n; a7 k6 z; O2 W, C+ `2 h% j
• 
  . v  Q& [% H$ M
  5 ~+ c8 k/ j( Y, ^    dic["num"] = 100+i
  ) C$ w3 e8 E3 E1 p
  
• 
  7 s' D9 D$ [* P4 j' c) [& l7 w
      print(dic.items())
  
  
• 
  3 h7 m8 Y. f1 }  l/ V0 h; R
  + t$ }8 [% l6 v/ Y  y
  " ~7 c# k, u5 U; g
  
• 
  # l( H, i- B. z$ \
  if __name__ == '__main__':
  
  
• 
  
  2 h# n! q6 Y5 M  c5 f1 E. r4 \    dic = Manager().dict()
  ' D9 K& b* I# d! ~! C" T" b# S
  
• 
  2 C" X! ~/ ]: q' k% t" a
      for i in range(10):
  
  / q1 R* U4 I4 |# [: V( J) F
• 
  
          p = Process(target=func, args=(i, dic))
  ( Q3 n2 }7 k3 P. Y
  
• 
  
          p.start()
  
  
• 
  , \$ _$ M4 K! v9 T/ w! O
          p.join()
  " \5 B* n% g. s+ i& q; s5 K
  
  4 W1 S' p& I- h4 ^/ @

运行结果：

• 
  
  2 Z( P& o% Q4 c1 s[('num', 100)]
  ' H* b2 H, T$ E2 |: d
    q# X1 m' i& I# a( J& L
• 
  
  0 n/ \  m9 U. a/ ^4 v8 {[('num', 101)]
  ) L1 k$ n5 o1 v  ]# B7 B1 x
  
• 
  
  " b5 ^% F9 f( n* h+ |# z4 N[('num', 102)]
  
  9 [: l5 ]6 |$ O3 F2 n- S, U; I
• 
  
  [('num', 103)]
  
  " ~5 B$ m6 G6 [) K( [( p( T& p' N7 d1 [+ Z
• 
  ' t. u+ ^8 G) |; o  h+ v* [4 t: b+ c3 a
    U7 U5 J; e# B# f8 A[('num', 104)]
  1 V& Z) G+ j2 i' ~6 Q6 g
  
• 
  " Z3 b( |& Y7 P0 _) V
  * B8 r8 a) N% l  v[('num', 105)]
  
  " t+ X7 h9 x+ j  f
• 
  
  [('num', 106)]
  " Y+ c+ p- m% X! ~: L$ g' t0 y4 d
  - y" N% ~4 u* C5 Z$ g' Y
• 
  5 A& z: H. U! ~
  [('num', 107)]
  % I$ {; u1 |  s6 `* E+ p0 s# B
  
• 
  & X5 N. q! l: o) t4 l  r- ?7 Y0 ]
  [('num', 108)]
  + B$ v* w# }: x1 T/ }4 n( N
  
• 
  % K: E& U" P4 [# _9 L
  [('num', 109)]
  
  
  

1.3 使用queues的Queue类共享数据

multiprocessing是一个包，它内部又一个queues模块，提供了一个Queue队列类，可以实现进程间的数据共享，如下例所示：

• 
  ; G$ Q5 M, x* k# _( e* o, V
  import multiprocessing
  & g4 f9 s+ X3 {: e; W; L; {$ d$ Q1 @
  0 n% ?9 x  O$ X3 a
• 
  
  ( i9 m0 c7 @8 O3 f, S0 J( i. qfrom multiprocessing import Process
  $ y7 ?9 h% q- x( m& `: T
  
• 
  6 X/ Q, ~- L$ J2 {2 f
  from multiprocessing import queues
  % U' W: L# E8 b6 l
  
• 
  
  : M( U( N( q& h! V5 N- y
  / |; w/ e/ v+ h7 X
  
• 
  
  def func(i, q):
  ! j" R$ E& U8 m7 v$ F8 g0 b
  ! k9 c. C  s# @3 f3 E* [1 T
• 
  $ \& |4 E0 b3 Q4 ~" R
      ret = q.get()
  2 @5 ^' q8 e! y5 J
  3 j' `& K' ^% s# L0 K6 [
• 
  
  % y' |; T% ]5 Q1 Y    print("进程%s从队列里获取了一个%s，然后又向队列里放入了一个%s" % (i, ret, i))
  " ^, G6 F3 W' q- d% d( @& I4 @
  
• 
  4 h& N0 j  T7 F; c5 J7 y
      q.put(i)
  ! ?% r: u: T9 N, @7 b' _' R7 Z
  9 Z. z2 n( }5 x6 {
• 
  $ x3 V" \( b& }, e
  3 v+ J* K/ T8 L7 M1 p2 i
  ' m- O* B2 N$ ~9 a$ B
  4 G$ D! X; S  P8 i. O1 K$ p
• 
  
  6 E8 U" B+ j( I, T/ {if __name__ == "__main__":
  
  
• 
  ! s" o* T6 \% Z1 e0 a
      lis = queues.Queue(20, ctx=multiprocessing)
  
  
• 
  
  3 d+ c- Y9 F' C& i" `: m7 s! X: C    lis.put(0)
  5 j$ \- h0 I5 i8 @
  1 h( O6 l2 b- g/ I- |
• 
  % A3 {3 R( d0 t# C. d! V
      for i in range(10):
  $ A+ r" y7 O  B; u: r& M! G
  . Q! D' r$ c0 b" W( }3 M( G- L
• 
    h1 q2 A# e) ?: v  J# W
  5 B4 O2 U6 `9 d& l4 g, c. F5 n- O        p = Process(target=func, args=(i, lis,))
  - P% P& p5 z; h- F! s
  $ K- j( w6 m4 R( Y' @! e5 P0 Z
• 
  
          p.start()
  
  
  % ?# i( o, l, @6 L

运行结果：

• 
  $ w. `0 Y- n9 r5 ]1 r' e, Q' x+ h
  8 ^# Q# t( m* L* T7 F7 }) _进程1从队列里获取了一个0，然后又向队列里放入了一个1
  
  
• 
  4 \+ ]8 ?! B, R- F! @5 L
  进程4从队列里获取了一个1，然后又向队列里放入了一个4
  " T5 `+ d  G! @2 U6 H5 Q
  
• 
  
  6 u* ~( ^1 W- t( g4 [进程2从队列里获取了一个4，然后又向队列里放入了一个2
  2 w$ j/ V: X6 \% @& A# |7 B7 V* P( Z
  
• 
  
  进程6从队列里获取了一个2，然后又向队列里放入了一个6
  
  
• 
  
  8 ^* q$ M' w, K8 x2 a进程0从队列里获取了一个6，然后又向队列里放入了一个0
  0 D, H! c; z0 K) y
  ' |6 W0 f) I$ x1 p: i2 t/ E
• 
  
  进程5从队列里获取了一个0，然后又向队列里放入了一个5
  
  : E/ `. v* |) b2 h+ B) F1 g. q
• 
  
  进程9从队列里获取了一个5，然后又向队列里放入了一个9
  
  ( c( e7 {7 _7 `5 F: B" T6 I+ d
• 
  
  5 o5 m2 i* S) _9 h( x! U- z  L" y进程7从队列里获取了一个9，然后又向队列里放入了一个7
    H5 U0 w- R1 y0 W5 X
  - M; y- g0 i& u5 i, c( H( E
• 
  
  进程3从队列里获取了一个7，然后又向队列里放入了一个3
  ) H# l8 A2 V! L! ]" \
  
• 
  % A% w. D, E( I. b# @# ^9 d7 @. d
  进程8从队列里获取了一个3，然后又向队列里放入了一个8
  ) {; D" o. K9 I( f) _2 ]
  
  , Y! H7 p) o) j  H2 K

关于queue和Queue，在Python库中非常频繁的出现，很容易就搞混淆了。甚至是multiprocessing自己还有一个Queue类(大写的Q)，一样能实现queues.Queue的功能，导入方式是from multiprocessing import Queue。

2. 进程锁

为了防止和多线程一样的出现数据抢夺和脏数据的问题，同样需要设置进程锁。与threading类似，在multiprocessing里也有同名的锁类RLock，Lock，Event，Condition和 Semaphore，连用法都是一样样的，这一点非常友好！

• 
  - j" ?4 v% A$ a7 \2 Z  p
  from multiprocessing import Process
    Q6 P" I8 \9 h0 ~; Q
  
• 
  / ^9 ]% f7 ?; w$ g) x
  from multiprocessing import Array
  
  ; C; K: L! N: ?  N- t6 I
• 
  
  from multiprocessing import RLock, Lock, Event, Condition, Semaphore
  
  
• 
  
  import time
  
  
• 
  ! O2 q) o/ r  T. i9 ^
  
  
  
• 
  
  def func(i,lis,lc):
  
  
• 
  ! p$ v+ |. n( Q0 `; E% Q) d
  1 k5 N' v0 Z+ b3 L! _" a& E    lc.acquire()
  
  
• 
  
      lis[0] = lis[0] - 1
  
    y- D% @+ u% q& K
• 
  
      time.sleep(1)
  
  / u+ |1 F: ~9 e9 T- t# d
• 
  
  2 D5 X( b$ `: ^* M' F0 E2 Q. H    print('say hi', lis[0])
  
  
• 
  
      lc.release()
  
  
• 
  
  , Y! L- Y9 f  o) c& s) p$ k& ]
  
  
• 
  
  1 |4 Q% ?4 o! D" q  K2 e) Lif __name__ == "__main__":
  $ ^$ }/ t  W# Q  ?1 f; r! V; Y
  4 b" W7 [( g: a) _" `8 J
• 
  
  5 [+ K) ]6 H; z2 f1 a; }# }    array = Array('i', 1)
  
  + }4 F! q0 ]; A" P* ^1 `4 l
• 
  : p2 p2 x) x- {. U! i* @! R
      array[0] = 10
  ) V- h3 L! G% u0 ^7 b0 k
  
• 
  
  9 c/ ?$ f: A, J: e: r9 h    lock = RLock()
  
  : \! u& _( p" z: B9 Z+ M, N
• 
  ; D' t  \3 R' S4 f- Z/ `
  7 D+ N! X' I2 Y    for i in range(10):
  
  
• 
  
  0 d) d' B% S) |        p = Process(target=func, args=(i, array, lock))
  
  " S; o+ @5 V; ?# c" ]- w7 |
• 
  2 z: J, s  `5 b
          p.start()
  
  # }! {% m. P3 t4 j
  

运行结果：

• 
  
  say hi 9
  
  
• 
  / X' Y5 T1 u1 Z7 R2 J/ [
  , c2 o( ^3 P  a7 R& y9 b: ?6 Jsay hi 8
  - s% `* N- }+ [  v
  & }: w% r0 W+ G* N
• 
  ( E4 {9 p6 L- n1 A
  say hi 7
  
  
• 
  : D% D: @+ o+ T  F& N$ j! K& I
  say hi 6
  / U: u2 l# c1 X
  - M5 S( @5 }# _7 @: Y8 \
• 
  - {) z  M0 ^8 H, T
  0 K* P- F- p6 M& b; @, H2 Zsay hi 5
  2 L% N) x  ~# [6 m4 K2 ~9 }7 [
  
• 
  
  say hi 4
  
  2 Y0 u; ^6 u  g: D+ I5 w
• 
  
  * _( L: M7 ?. Osay hi 3
  8 x0 d5 p7 ^: _% ?
  
• 
  
  say hi 2
  6 f. S/ t+ ~4 r8 ]& @
  1 X/ H+ J) h3 P  Q
• 
  . {$ I" P" f  J' z$ i- P' o
  : Z+ [7 N0 p1 l( B* ~2 f. `/ Qsay hi 1
  5 M3 {  x( p- c' `
  
• 
  
  say hi 0
  
  / c: {3 P0 ]4 u: L
  9 |# n$ x5 ]; B# S* V8 [

3. 进程池Pool类

进程启动的开销比较大，过多的创建新进程会消耗大量的内存空间。仿照线程池的做法，我们可以使用进程池控制内存开销。

比较幸运的是，Python给我们内置了一个进程池，不需要像线程池那样要自己写，你只需要简单的from multiprocessing import Pool导入就行。进程池内部维护了一个进程序列，需要时就去进程池中拿取一个进程，如果进程池序列中没有可供使用的进程，那么程序就会等待，直到进程池中有可用进程为止。

进程池中常用的方法：

• apply() 同步执行（串行）

• apply_async() 异步执行（并行）

• terminate() 立刻关闭进程池

• join() 主进程等待所有子进程执行完毕。必须在close或terminate()之后。

• close() 等待所有进程结束后，才关闭进程池。

  
  

• 
  
  $ V) w7 N4 D- ?6 ~7 l$ D( bfrom multiprocessing import Pool
  
  % Q# V. q& h3 b' j$ o5 B- a
• 
  . ]8 V0 b9 Y$ m' [; p: \# c9 O2 l; \
  % P( g5 k3 _: t0 ]& i; Himport time
  
  ) o& N' X. W. ?$ W; T- u; }* b5 o
• 
  / F  i, a9 T+ g" G  U
  ' H4 n6 A1 ?' c' |0 N
  " L4 z0 H4 i, N8 I9 h5 l( B7 w( J
  
• 
  % i3 Z5 A1 u& A; @. z
  def func(args):
  2 Q$ B0 I0 |  s1 E" F
  9 o9 K8 L* K1 V( F5 D
• 
  
  . b+ P/ n# c" b2 J7 l    time.sleep(1)
  
  
• 
  6 L) u* f& e5 V6 ^' G+ N% U
      print("正在执行进程 ", args)
  # \3 o# w* _3 _8 v
  
• 
  
  9 t& K* n/ j: }% G8 @* v4 |' u
  
  
• 
  $ z0 ]) C$ R. ?1 z# C
  if __name__ == '__main__':
  0 ]% T2 }2 g( T& _$ }% |
  
• 
  2 n8 m% J+ u& R$ |
  
  
  
• 
  ' e7 ?. n3 B# P, u, u; P% h# Q, T
      p = Pool(5)     # 创建一个包含5个进程的进程池
  
  
• 
  
  3 v! n# n3 o5 W
  
  1 n* h% m8 C# R5 h2 Z& U
• 
  0 v, ]& G- g9 e
  0 [' d7 z; n' J5 n9 O+ ?% l) C# u    for i in range(30):
  ' j- ?6 e; k! O+ H5 z7 t# T
  
• 
  
  : G% C: A+ x' b$ o. E* [1 `        p.apply_async(func=func, args=(i,))
  
  
• 
  
  
  0 F' ?5 z$ {( a$ t4 f" G1 P( s2 P
  ) w8 e2 V( W& U/ A0 m- G& a! n
• 
  
  # @" b0 c( Y+ Y9 u3 K    p.close()           # 等子进程执行完毕后关闭进程池
  7 c1 u$ a3 j  j$ I& V1 I- i
  - Q+ g/ ^4 K8 Y$ q2 F
• 
    v! _: m: o" P$ M" v7 c" o/ c6 z. b! ?
      # time.sleep(2)
  , \9 ^  c0 l7 h( V0 N5 [
  
• 
  ( x: Q7 V* W! U& T  @! k# B! H
  + e  [" N4 s" f    # p.terminate()     # 立刻关闭进程池
  , N" ?; o- S# m) n$ t) p! L
  
• 
  % H$ a1 s/ x- F' N
  . X8 ?: {& a- A/ ]7 L    p.join()
  & q) E' T& F$ Z4 C* L
  ) U3 J+ A0 Y4 D; m
  

请继续关注我

---

欢迎光临 数学建模社区-数学中国 (http://www.madio.net/)

Powered by Discuz! X2.5