爬虫（七十）多进程multiprocess（六十一）

杨利霞

爬虫（七十）多进程multiprocess（六十一）
' x8 K- P' |* K0 G

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

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

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

• 
  % z8 R# {/ N: X" B
  import os
  & T2 v' s6 ], P( d2 J
  
• 
  
  import multiprocessing
  
  
• 
  
  
  & c. n; p5 H0 B4 p. {
  
• 
  
  def foo(i):
  
  
• 
  
      # 同样的参数传递方法
  
  
• 
  4 X8 l$ N9 @- f  {1 R3 T2 b
      print("这里是 ", multiprocessing.current_process().name)
  
  
• 
  
      print('模块名称:', __name__)
  5 O$ E4 S4 E! U; `! R
    e5 s+ Q0 b7 Q% N/ O: P
• 
  : w& G* D2 _+ T; ~5 _/ c
      print('父进程 id:', os.getppid())  # 获取父进程id
  
  4 L3 h1 \! w% I
• 
  
      print('当前子进程 id:', os.getpid())  # 获取自己的进程id
  1 d6 l6 e- A0 U% R
  * t9 g$ {5 D$ y3 \" {, L1 ?
• 
  ' o6 [! x' ]/ P' O
      print('------------------------')
  ( D7 x# |2 n, P/ o' R3 I0 f0 X
  - u5 ]0 N$ q  d6 a6 R
• 
  
  8 g: m0 Z3 ?, \$ r) R# E
  
  / g6 M- |: t6 a$ N) G
• 
  
  if __name__ == '__main__':
  
  ! H3 U- N( I" O! d
• 
  
  
    e; p" v4 q& y$ b/ Q- J) d
  
• 
  4 \) a2 ?! u2 P5 j+ m0 P; ]! w
  % @* J; I4 D- h, x& ?; w7 o& j    for i in range(5):
  6 a# k1 }$ A0 ]- |0 x" ^0 F
  , n7 Z1 d- {$ M$ i  S
• 
  4 J, U2 E2 H: L2 m! {
  7 I- d% U+ I6 X        p = multiprocessing.Process(target=foo, args=(i,))
  + L& K6 X! v5 {! n% f7 m& F% n
  * ]3 j" ~; `, {  m
• 
  - B! W+ j& @4 i( x
          p.start()
  
  2 w0 ~! W& h. t3 w9 B& ]
  

运行结果：

• 
  
  ' _, f1 G; Y/ l4 f这里是  Process-2
  
  " G  _! s, A) A( y3 `1 ]( g5 D
• 
  # j" K1 I6 r" ~+ t) b, Q
  模块名称: __mp_main__
  9 @" ^' [- i9 z1 n! `
  
• 
  " Z  M* c0 T) a0 p4 ]- O1 A+ h- W
  父进程 id: 880
  
  
• 
  ; J* s' m4 ^4 I5 B5 N1 I- f
  2 H: U$ A" _% V& s" W当前子进程 id: 5260
  
  
• 
  
  --------------
  " w) U/ I' D) S
  ( S" K4 Y; `9 x( p& @
• 
  
  这里是  Process-3
  ' d. w6 i/ c, N, i; u
  5 L) X# A/ }1 C( G0 H
• 
  * H; M2 @8 t$ y: _9 k5 X6 i
  模块名称: __mp_main__
  
  $ t2 v, @' K" p: d
• 
  ; ^  c* g6 [. Z5 Z3 N3 N! M: \  k
  父进程 id: 880
  & d2 H8 ^% [) a( N
  
• 
  9 K1 d2 M; [  C
  当前子进程 id: 4912
  
  
• 
  % ^& z: ?% C2 ]" w1 c: o
    S( z1 U0 N2 n1 ]8 i. w% t--------------
  
  
• 
  
  这里是  Process-4
  5 S" r5 ]! y2 @) I( g6 f4 M
  . L+ i+ \  ?3 x7 P8 G9 F
• 
  ) ^$ _/ k% y" T$ y4 F5 D5 `
  模块名称: __mp_main__
  $ n+ P- W9 y' c" R/ P1 S. I
  ) ]0 J! O0 V" W" ~* C4 y( \4 O, p
• 
  
  1 ^* A  d  |' w# m- ^  y3 Z父进程 id: 880
  3 _& N0 o( w5 C/ m1 V2 W
  
• 
  % C2 {0 o6 ^/ s7 ]/ @7 `) E
  当前子进程 id: 5176
  
  , ^! z+ R# r0 G
• 
  / l' a+ z* l) i, Q* L9 f5 y4 w
  1 R* h1 M% y8 }--------------
  
  
• 
  
  8 J: G* F) F. V! [' n这里是  Process-1
  ! _7 R# ?9 u0 |7 I6 a2 t, O
  
• 
  
  模块名称: __mp_main__
  7 F. I+ k! t7 c& T/ t
  
• 
  
  父进程 id: 880
  1 f; P: w* K- P6 E* Y
  
• 
  6 {" ~: O- o/ s$ o5 z0 a& ~
  + }, a, `, V% M( L0 s( l" k当前子进程 id: 5380
  
  1 ]9 [1 O8 N/ ]" E' {
• 
  
  : ~/ X  u; D+ Z% G--------------
  
  
• 
  2 e3 z- F+ h% J" ]- O
  , U9 F  W; q9 {% E2 f这里是  Process-5
  9 x* z' e' i6 {) \* F" A  K, n
  
• 
  1 l: e" L7 z9 e% i& n3 {! \
  模块名称: __mp_main__
  $ Z; w. c% w3 ]0 x+ `1 J
  & I7 t' S. @; g2 q- j  E9 O1 F0 {. b% Q
• 
  
  父进程 id: 880
  ! c6 C4 R& C0 a) {2 d& r( N
  * P+ o4 N1 |5 `' N7 ]  @
• 
  / W! m9 f! g2 p8 z: K
  当前子进程 id: 3520
  : F# @, r& p+ ~- U, _0 ?
  ' M0 e: h2 p7 o! u
• 
  ; [- H( }: h/ f% p* V# W
  --------------
  
    W: z9 o, k% e  q- n
  

1. 进程间的数据共享

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

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

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

• 
  
  from multiprocessing import Process
    P6 N' {) `3 j1 [- u- z
  
• 
  
  
  
  $ A& N/ a" G/ M8 ?' ~
• 
  * g0 h2 N0 l2 ~: A  t7 I6 H
    H& [/ Y0 m8 R& B7 |lis = []
    w) _; K% _) O2 v) o
  
• 
  " p" |; _* i( x# Z6 U
  ( ?1 d$ K) l6 N0 z7 r
  
  
• 
  
  def foo(i):
  . }  E  D6 P7 Q7 K, J7 K
  2 [4 Z" U) `5 G& J1 ^6 Q6 w/ x& H
• 
  
  + X$ U) T+ X1 w* d# B4 x% `    lis.append(i)
    W2 j9 W1 e) E% q* K
  
• 
  2 \) ~& Y' d  L, N8 E# @3 n
      print("This is Process ", i," and lis is ", lis, " and lis.address is  ", id(lis))
  
  % a) I) I3 A8 x+ {* k- A6 b2 m
• 
  ' h% p# \  ~# ]+ ?
  
  
  2 X% y1 c  E0 q7 `
• 
  $ c! G9 R/ h- ^7 V) [1 c3 g
  if __name__ == '__main__':
  
  
• 
  - `9 ]+ J4 h" L, _) R' X& D
      for i in range(5):
  
  
• 
  ; [. m  W  q# Y8 T1 D9 P/ ~
  ; E& o" O& L, K/ L8 A        p = Process(target=foo, args=(i,))
  
  
• 
  
  5 O. @0 Z. i# _: Z2 M& z, d        p.start()
  
  & Z: b& L8 E( T# F4 L# v5 E
• 
  
      print("The end of list_1:", lis)
  
  ! H/ w- G# `7 X) b* ?- l
  

运行结果：

• 
  
  The end of list_1: []
  
  / h. C9 H" V2 b3 O
• 
  * u# @% G% W2 o
  2 y3 f2 b) G0 I% lThis is Process  2  and lis is  [2]  and lis.address is   40356744
  
  
• 
  
  This is Process  1  and lis is  [1]  and lis.address is   40291208
  & \+ G+ q" S" g7 _- |8 [' P# ^
  
• 
  ' x6 f2 z" M" }6 F, V
  6 Z3 f3 g" N& J: xThis is Process  0  and lis is  [0]  and lis.address is   40291208
  
  8 S/ L0 j2 ~% ]- _; H
• 
  
  % Z% p- G6 W1 Z$ Z* U* @5 SThis is Process  3  and lis is  [3]  and lis.address is   40225672
  
  
• 
  0 T( P. F1 h3 d/ @1 w6 V
  3 ^) T8 m7 ?5 Y( L$ LThis is Process  4  and lis is  [4]  and lis.address is   40291208
  
  
  # @0 h' w# R* a; U; H

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

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

1.1 使用Array共享数据

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

• 
  
  6 O* t/ l  k2 m2 n. G'c': ctypes.c_char, 'u': ctypes.c_wchar,
  
  
• 
  
  , C" b# i6 q( \# ]- S5 i'b': ctypes.c_byte, 'B': ctypes.c_ubyte,
  
  + h9 H3 P# D; ]) E; D0 l
• 
  4 o0 ]3 e0 i7 v$ r5 `+ L
  - Y0 r" Z/ B  p1 Y4 ?'h': ctypes.c_short, 'H': ctypes.c_ushort,
  
  . ^1 |1 _% {3 N) {* i" R# x: b
• 
  + j+ P5 A9 P# d- Y4 u: O5 _
  'i': ctypes.c_int, 'I': ctypes.c_uint,
  
    ^: c1 ]& R* c  a9 X
• 
  
  'l': ctypes.c_long, 'L': ctypes.c_ulong,
  
  
• 
  # X  ^% X& y( y$ T" F& l6 u
  ; z, b  \1 ~& Y'f': ctypes.c_float, 'd': ctypes.c_double
  
  ' b8 m! u$ g: g% L/ f0 ?2 ]( e
  

看下面的例子：

• 
  3 R$ Y% W+ Z/ P% V
  * @3 `  E" j$ R/ }* ~# gfrom multiprocessing import Process
  
  % J' i7 n7 g6 b8 M& J  P' Z9 g2 d
• 
  # E7 ?3 ?9 {9 l- v1 u4 @; o
  ) C2 ]; e( k* C  i7 M. s% |from multiprocessing import Array
  
  
• 
  : F3 E) [4 P; g( T
  
  
  
• 
  
  & d' [7 b' x" E: p  n% w! \& _def func(i,temp):
  
  
• 
  ( y, `  h0 Q7 s! j5 p; _) N- L
      temp[0] += 100
  / H4 C/ {* M. e  N5 s- }& t# q
  ; G7 A3 ]: j6 p# j6 |4 {' \2 h. B
• 
  1 `7 F# o1 E$ q! @5 p" v) l
  , p$ {" ]  E/ G& V* \    print("进程%s " % i, ' 修改数组第一个元素后----->', temp[0])
  % ]! W+ p0 W0 l5 s" y
  
• 
  
  ; Z4 n1 m: P' d6 L( C! M% @
  7 O. f" ^, O2 n, s- N
  
• 
  / U( A+ \; }- l" v, x  T
  : [1 N, O0 T1 Q7 Gif __name__ == '__main__':
  ! |2 ^' M' \' i# W/ a
  7 h3 B" j/ G; V$ E8 N
• 
  6 T+ K! E- l, b4 x) J
      temp = Array('i', [1, 2, 3, 4])
  * `  m9 G# h$ X9 i  X
  
• 
  ) Q) r' r' G4 C
      for i in range(10):
  & s, E5 E8 n! [
  ( q3 ?! H) D% \8 D( t4 O
• 
  
  7 M: E6 m1 p3 n4 B* X, q/ p        p = Process(target=func, args=(i, temp))
  $ E8 d. r! c5 w5 ]- m
  
• 
  
  ( V! I8 W/ u- d' G: t' h# T        p.start()
  
  - d7 v1 {0 q  q
  

运行结果：

• 
  
  进程2   修改数组第一个元素后-----> 101
  & A6 q- u" t$ c- v& o
  " ]9 [* p1 j0 ]/ M5 J, C
• 
  
  7 K7 \* m) V' h* j+ w$ Z进程4   修改数组第一个元素后-----> 201
  . }# k) V6 \# T% W8 _
  , q8 Z4 W* B! w( X# o
• 
  & |) l% Q* [# s' L8 R5 H6 t7 e
  7 g- r! m4 ~- F5 T) v6 t进程5   修改数组第一个元素后-----> 301
  
  $ D& k$ c& P6 y3 O; V6 z
• 
  3 V* {5 Y! z  a+ \: @3 u
  进程3   修改数组第一个元素后-----> 401
  * }' u5 f( O4 o
  
• 
  7 z5 Q4 C  P. c0 T7 E# H3 E! N: ^
  进程1   修改数组第一个元素后-----> 501
  
  " o7 v2 v3 P$ ~# O- G& x5 v* W" W; s% E
• 
  
  进程6   修改数组第一个元素后-----> 601
  + T8 h% R0 C9 H" y5 d% D* H. h
  
• 
  
  & z; p0 i8 f: y4 D, d: [  P进程9   修改数组第一个元素后-----> 701
  # N' O& k, [5 P1 [! l" H! z4 s% g
  
• 
  
  3 Q' u! ?4 U0 @' w进程8   修改数组第一个元素后-----> 801
  
  
• 
  
  进程0   修改数组第一个元素后-----> 901
  * l, y$ Z! x9 y& K4 T; F
  
• 
  
  进程7   修改数组第一个元素后-----> 1001
  3 k. b. b/ ?% ~! Z+ _3 Q7 A
  ' h/ d, j3 V+ t% R6 P) N
  

1.2 使用Manager共享数据

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

• 
  
  . O  @' Y. `6 f% Lfrom multiprocessing import Process
  
  
• 
  - W1 O4 ^$ H: L  q! H
  from multiprocessing import Manager
  
  8 r! v3 ~2 g* w# q4 J
• 
  ! f- W" [) p" D1 v: i
  : O7 N" S7 I) I  v) w% G
  
  
• 
  % `& `" o0 O/ m( R: d( D
  * v3 |6 l8 U6 l# N# m5 x' xdef func(i, dic):
  
  
• 
  
  . N9 i6 \% S. E9 z  K    dic["num"] = 100+i
  
  
• 
  
      print(dic.items())
  
  ) g5 A) Q! l  Q7 B% B% R
• 
  
  
  $ I8 b! x$ t5 d+ A6 e: k/ t
  
• 
  4 U/ `: X5 W1 C+ B8 N" D
  if __name__ == '__main__':
  5 J/ r$ C6 l7 d. V6 q9 t$ d# x+ b
  
• 
  - l' F8 Q! b) Q/ U0 W* |
      dic = Manager().dict()
  
  
• 
  
      for i in range(10):
  - d) L! G' d3 N
  
• 
  7 ?, V) |8 ^/ b) c1 |' A
          p = Process(target=func, args=(i, dic))
  1 n( j; f4 P3 s2 _
  
• 
  1 K( \& U8 Y; F( R7 Z7 C
          p.start()
  
  ' D) V0 W8 e$ e  O
• 
  
          p.join()
  ' X+ f7 @9 E/ M/ }0 A" ~4 I9 S+ x
  3 {/ J) E  S0 t2 }& @
  & o2 y8 X: ~3 ~0 o8 ?

运行结果：

• 
  % |, E( `9 ~1 {4 c' }
  4 S+ t. e' f  E. t2 U6 z[('num', 100)]
  
  6 b; u0 p5 o- X! m6 n
• 
  3 c2 j" u, I5 `. V' n& C
  7 i2 O( o# \1 o  ]- b+ ?[('num', 101)]
  
  
• 
  . r" x' P2 I7 x2 l
  [('num', 102)]
    Z2 T- {2 U+ T3 n- h
  - h% {# P7 X: D4 X
• 
  
  & f  ^7 `( \9 {/ c7 G6 @% r[('num', 103)]
  . X9 s" ]6 x; d) P: B) O
  
• 
  $ K: Y4 `; L  A7 K4 L( t; {
  [('num', 104)]
  
  $ w- w+ F4 O8 a1 T/ A8 g) M+ z
• 
  
  [('num', 105)]
  / N# g: ]. W) c  M5 @. o" ^
  % p0 h  V# [* ?& q! M
• 
  
  7 o% @/ F2 m  J# d4 Y$ z0 J3 T[('num', 106)]
  
  2 m  x& u0 u$ e9 K3 M
• 
  
  : S' @6 U6 K0 l" g! z8 ^' l3 j7 }[('num', 107)]
  
  
• 
  
  8 N( L! a1 ]& q7 ^& o: l[('num', 108)]
  . g8 o) h9 \- i% Y* B/ k
  2 V, q* j$ n( q7 f
• 
  5 q% K3 F3 Y6 d! }: ^& @
  + l; Z9 T; r! N3 x5 l& m; ~[('num', 109)]
  
  
  # a+ T" k# J- f- r" N6 P

1.3 使用queues的Queue类共享数据

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

• 
  
  3 ?: Q0 }3 }- s# i$ T" Zimport multiprocessing
  , B6 a5 i. i. f: G
  
• 
  ; v& h4 q+ E7 u; Y; q/ B
  # O0 E' L' G+ H) a! }from multiprocessing import Process
  
  7 k3 Q( a; U5 ^: m5 q' _
• 
  
  from multiprocessing import queues
    F7 ?; g- y1 U; D4 t9 b+ ?
  * ^! _; V; }$ \9 F, ]) M' b5 v
• 
  : Z; b& O. Y# h/ x8 Y' ?2 e
  6 B6 t4 K& b* {5 S$ o' X
  4 @; u4 }5 F; m$ M1 D
  2 M) V* L: Y2 t5 F+ M4 z
• 
  
  ) T  M+ J- `% P& ydef func(i, q):
  : r9 {6 E/ _! g2 n) \! ?7 Z2 U
  
• 
  0 s; j" Q( W0 K2 t6 ~  e1 `- l
  4 a8 e7 O0 ], S- a, L! o2 g3 W    ret = q.get()
  
  1 R$ H8 D8 p' W+ {, G  t2 N$ w
• 
  
      print("进程%s从队列里获取了一个%s，然后又向队列里放入了一个%s" % (i, ret, i))
  
  0 k: ?# x7 b; p  {# p
• 
  
  , P4 D% X- P; a9 ~1 k$ |    q.put(i)
  7 ?! z/ `. _4 m/ G! a0 O1 N
  4 L* W4 ~( \# S* m& l' ]& H
• 
  
  3 }7 o) q; v, _; |/ V+ `
  
  
• 
  9 Q! v8 o0 `0 e0 ^7 k
  if __name__ == "__main__":
  2 f+ {, s5 K3 L* c( \4 l( R" \
  
• 
  ) D" _9 O, z6 n% c+ s3 e4 D8 W: T
      lis = queues.Queue(20, ctx=multiprocessing)
  
  $ @0 {5 L3 K& Z( p* Q5 M
• 
  * s+ @0 m/ _( a- a: n- O  ]; _! C' \
  " S6 U" A( h5 D! x8 G3 a+ U# [    lis.put(0)
  
  
• 
  
  0 ^; j  a! H; r; G" B  i. B    for i in range(10):
  
  
• 
  % A6 ]6 D- |: ^0 V0 j7 V
  1 }! n: G# V0 L1 h6 e, c7 `9 t; t        p = Process(target=func, args=(i, lis,))
  & @) r. [* M2 L# }! j  W
  6 \; w( [8 e+ G! k- Q
• 
  
          p.start()
  2 b; [5 y# G$ y$ n) A8 I% ^0 I
  & |* `; E7 t" k) S, h' G
  . N( d8 N6 \' S% Z" P5 |) b$ a

运行结果：

• 
  
  8 t' a3 O6 V7 C$ f6 D# C" M, f进程1从队列里获取了一个0，然后又向队列里放入了一个1
  
  5 F7 r, o& _; T1 i+ r% P, Q
• 
  
  ( `/ f! H$ Z5 c7 w& u- Y, a- [4 S进程4从队列里获取了一个1，然后又向队列里放入了一个4
    z9 t$ L* X, b2 K
  3 K1 n  ]1 _& H+ x, G" \- U5 m" O& G
• 
  ! l2 b, i, v! w9 w
  " \/ N# U+ }2 ?3 f7 J进程2从队列里获取了一个4，然后又向队列里放入了一个2
  
  # X- J, v& B$ o4 K/ \5 W1 Z; [
• 
  
  进程6从队列里获取了一个2，然后又向队列里放入了一个6
  1 w2 V/ F$ [/ g- b* _6 O
  ( e& W- F7 N' Q
• 
  
  进程0从队列里获取了一个6，然后又向队列里放入了一个0
  
  
• 
  4 C  ^0 [7 J+ `9 N2 K  y7 R
  2 E' P' A# h- W+ \; e0 U% Y进程5从队列里获取了一个0，然后又向队列里放入了一个5
    I" B( \5 t9 Z+ w& Y1 h3 C: W# z
  + E# M$ p' s8 P$ C5 Q3 v8 v
• 
  1 o: `7 G. o5 P3 Z" z/ m
  ; q) b8 d" `* x; \进程9从队列里获取了一个5，然后又向队列里放入了一个9
  
  
• 
  " L" y3 M# g6 P; M# r
  进程7从队列里获取了一个9，然后又向队列里放入了一个7
  : s* C, r5 B- o8 [1 Q! B
  
• 
  
  ' u. j, |/ m9 G/ j8 M* U进程3从队列里获取了一个7，然后又向队列里放入了一个3
  8 n$ i' s' K4 Z% g- Z' ?: d
  * h3 v4 A9 a: K( Y8 |
• 
  , o+ j  R2 W$ w9 m
  5 k* w: z0 ^7 |) L0 k! s进程8从队列里获取了一个3，然后又向队列里放入了一个8
  
  - x% u( n& j* u5 t
  ; o/ Y! C! w% E3 @

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

2. 进程锁

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

• 
  ' k3 s! {: @! q0 M% \  z$ T  A
  - p! P, I: b1 P, g, n! X, Jfrom multiprocessing import Process
  
  ( _0 |( Q& ]/ l' m) ?2 ~
• 
  3 a7 T; \! U6 n  d" k! T6 h
  from multiprocessing import Array
  
  % i7 {" L8 b7 r& {$ k
• 
  ' K* M& |- f$ h: H7 T% o$ D
  5 _3 u3 R( i; l4 A' V8 ]  afrom multiprocessing import RLock, Lock, Event, Condition, Semaphore
  
  
• 
  
  ' q  G- U: y$ C0 r& A( {6 Ximport time
  
  * _4 ^# l2 e# Z6 d3 y
• 
  
  ; T$ b; M5 e9 x/ q2 s( x
  
  : `( C5 b8 ]( ?  t
• 
  
  def func(i,lis,lc):
  
  7 s0 e: O9 B" {# h+ V* D
• 
  
      lc.acquire()
  - O4 {; i* x3 N3 e; j4 Z8 D, f
  
• 
  
      lis[0] = lis[0] - 1
  
  
• 
  4 z0 r4 P2 ]* V* V
      time.sleep(1)
  
  
• 
  , L' `0 p/ Q3 e% q: D
      print('say hi', lis[0])
  
  ' E0 k2 w* ?/ {. Q. T
• 
  6 ]% u! s' G  Y
  1 W0 |3 C% N$ z    lc.release()
  
  
• 
  
  
  8 @5 f& M- n3 V. V
  0 I' o6 r8 T/ b: K2 b* ^9 R
• 
  7 `/ E& E5 j2 @' O
  if __name__ == "__main__":
  & x7 Y7 w# u* x6 z5 }+ R
  
• 
  
      array = Array('i', 1)
  
  0 D5 O4 |+ e! b% ?8 P
• 
  / c7 F" p: y3 g/ K) q
  4 N' w8 ^0 b7 O    array[0] = 10
  9 A: Z5 s8 d+ c9 |& \$ @  u" c* X  o
  
• 
  
      lock = RLock()
  
  
• 
  ; H0 w! r) E) ]
  ' Z& [5 N5 U0 Z7 T% d    for i in range(10):
  * ^& |6 C8 c" c6 S% G
  8 C3 S% l- F' Q/ Q$ h7 O9 i  D
• 
  * q( Z1 [) @, Z
  & \9 j, X- O$ X7 |# n! h$ X# q, x: r! R4 P        p = Process(target=func, args=(i, array, lock))
  # ~( Y3 a2 Q6 K* ~4 d
  6 C! n$ `- H2 J
• 
  
          p.start()
  . _) @6 A4 k) f& a: ~
  
  

运行结果：

• 
  
  say hi 9
  # ?0 Z8 B; q$ p
  , D' u5 |" \! o7 K6 a
• 
  , u- z* p0 [: P7 b1 |3 {) {2 x+ N
  say hi 8
  
  + _: ~" C9 V# A
• 
  ( L6 L( P0 m; j# Y1 h
  say hi 7
  
  1 F& j% R4 q# T: n' D! Q- ]
• 
  
  $ M0 l4 n; Y9 Csay hi 6
  9 u1 c4 s4 n. @$ [; |9 j
  
• 
  
  * U& F* b( ?: p# q, D1 V5 C8 Q- Jsay hi 5
  $ x* Y0 [* W4 w7 z- J" {4 W* L4 [
  
• 
  $ G+ i4 T; z! y) }7 G' m1 n
  say hi 4
  
  . E( f. i- m8 o( Y4 m  E
• 
  
  8 Z; |9 v1 T- y3 ]7 W) A. N0 Hsay hi 3
  0 T9 G0 t1 `8 N# l5 m. d9 S% E
  
• 
  & N$ q4 v' x5 l1 l) S  t- u( }4 T
  7 S8 N  m# C# B1 X; |' [5 i1 p) }say hi 2
  , W# a# f% e" Z# M6 U
  , E# e7 r7 _" p& n
• 
  9 `" P# j6 I* `# p/ H( @
  ) T) ~5 ~; ^0 e. o" }, Usay hi 1
  
  
• 
  ' J3 O! B7 v' B3 I% B- V
  6 r9 |# C3 D& x; dsay hi 0
  
  4 G9 c; e1 p" a' D; `  T
  

3. 进程池Pool类

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

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

进程池中常用的方法：

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

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

• terminate() 立刻关闭进程池

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

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

  
  

• 
  
  " c0 X8 l, x" f3 Sfrom multiprocessing import Pool
  . L/ E, y9 n9 }' G' J/ q/ y# B
  $ ~7 S9 a; p2 w( D* f7 Y% [/ j
• 
  
  import time
  
  
• 
  
  
  
  
• 
  8 q: A" t3 R+ ~' v
  def func(args):
  ( Q) a; s( y( T) I
    {0 h+ u0 u& U4 s" V* m& _. t7 ?
• 
  
      time.sleep(1)
  ! K  D) }  R+ w( i
  
• 
  * F/ t$ z' r  F* v2 n4 S) E. q+ n4 w
      print("正在执行进程 ", args)
  
  
• 
  8 N2 `) d2 B9 q
  . [8 ~, G+ l9 R
  + V6 @* w. b5 O2 P1 i' n3 M
  
• 
  7 z; D6 p4 ?+ B( g: S
  , O7 S. c1 x4 Eif __name__ == '__main__':
  ; b4 b, N+ D! E
  $ J: f2 C8 [4 r3 U
• 
  
  / v( A' G+ e1 V+ J0 E9 o: V+ n
  
  
• 
  6 A$ [, H" P% {: S9 S
  2 \6 L+ a  G, V' f+ \    p = Pool(5)     # 创建一个包含5个进程的进程池
  
  
• 
  
  / S* k) @1 h* G' b
  
  
• 
  * o* R- [3 @1 L$ F6 H2 y3 c) \2 \
  0 ~% U$ V% Z) H0 _8 o) _    for i in range(30):
  % e0 p% R, V- J, Z  s
  
• 
  - N$ x% Q9 E( k' m+ ^( Y  q& S: D; C
          p.apply_async(func=func, args=(i,))
  
  " T$ t: }- _- R! Y7 A1 d
• 
  
  
  
  5 n; N$ r. z! h8 H
• 
  6 x$ ^: S4 E. Y) W6 Z
  ) o  K- @( M: u, v    p.close()           # 等子进程执行完毕后关闭进程池
  
  ( K/ R, u4 G% I9 l
• 
  
      # time.sleep(2)
  
  # P; C" K3 X# O6 Y5 i
• 
  
      # p.terminate()     # 立刻关闭进程池
  * L4 @( h" f) i. q
  
• 
  
      p.join()
  6 W& y# `+ ?6 L- L+ k7 _
  
  

5 W, F0 `3 J. q3 n; M

请继续关注我

; ~& [5 L4 y" Y1 C8 ?
- j; i7 i0 S$ S9 w& M