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

杨利霞

: Y% D; G- Z5 X# {8 T+ d& Z% c$ {: B爬虫（七十）多进程multiprocess（六十一）
) `8 p8 K% S5 W; E

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

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

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

• 
  ( V9 x* E* g* L' _) t$ ?
  + y2 r# N3 O- H* ^* `5 G6 }. g" mimport os
  
  7 ?2 j3 f5 {8 \1 ^, g: C$ @" D3 m3 }
• 
  
  - ?8 R' |$ Q( J3 y# L7 m9 [$ ximport multiprocessing
  
  
• 
  6 a& L" z$ n, D9 y
  8 O& P# h8 g' U' N, r
  - C4 g/ y/ A2 g" z( s
  # y$ v7 M. {: ^0 }. O/ j8 n8 v2 }
• 
  * S9 G7 X% Q! \* _9 t# x
  ; \' e+ o4 l2 d5 p7 Bdef foo(i):
  
  
• 
  : R( ]8 B+ Y' S
      # 同样的参数传递方法
  ; T0 Y0 A, l3 Z5 I; v3 f/ h& y
  4 i; R' Y7 ~& m  I+ u
• 
  2 ~; t/ n- V7 y. U9 M: m% c1 P, x: Y
  ( d! D3 J/ V* i% f    print("这里是 ", multiprocessing.current_process().name)
  
  5 s6 \4 i! `7 w8 r% F; V8 G9 e$ g
• 
  
      print('模块名称:', __name__)
  ! |/ M% V7 h0 g8 C0 d: E' j
  " ~& i& E$ m+ ^# [& `: ~/ B9 P' [( p
• 
  3 p$ y8 v' T; L' Y' O
  6 ^3 @& `  N! F! Y5 T2 B; m    print('父进程 id:', os.getppid())  # 获取父进程id
  4 W; G" B! o0 S9 A
  
• 
  0 v6 r4 ^5 t  i; P# Z( S7 W
  7 A" p5 x; S& b    print('当前子进程 id:', os.getpid())  # 获取自己的进程id
  
  ( I% U/ ?1 {8 t& x. m  Z) c  {- p
• 
  - V* U2 p- ?! r+ M& c) x
  # r5 i  Z, \. l# k    print('------------------------')
  ) r( Q% @9 {$ r% i$ S& x
  
• 
  ; c3 L9 |- t8 K" o8 m
  / M6 G4 [% D4 z1 H7 n& O
  % b" j9 M6 J, U9 d* D/ d/ \' A1 b1 V
  
• 
  
  if __name__ == '__main__':
  
  
• 
  ( y8 Q: k* p( o" e2 m  J
  
  ( R/ g, V- m. I2 I1 J% d
  ' i& [0 s- @5 \" G! i
• 
  7 v/ H% m# _: M2 X9 g8 |8 V
      for i in range(5):
  
  4 t, t2 [. g# \
• 
  $ s7 V5 v# M: T0 L$ s
          p = multiprocessing.Process(target=foo, args=(i,))
  0 _8 \% H: }4 R8 S* K5 U
  4 R5 ?  C& D, }% e$ u8 a6 B* O* O' _
• 
  
  3 \+ H- y7 [2 t+ o, M: q3 M' F        p.start()
  ' G6 a4 G8 f, a  f! r# S+ [
  4 s1 T* T! @. c; |1 h; N: O5 M
  * [  l" T+ G  f2 D( M4 k7 G1 b

运行结果：

• 
  
  ) A1 k* R4 x" j$ I) u2 D1 T这里是  Process-2
  1 o* k6 w5 y/ e& ~1 R
  
• 
  
  8 @7 J, J* K, O模块名称: __mp_main__
  4 G1 t6 V4 ?  k& p
  4 S' Z2 U9 k' K+ w% C
• 
  
  父进程 id: 880
  / H& @9 H) {* n
  
• 
  
  ' o: e, [/ P9 k& t6 `) Z* B% ~3 ?当前子进程 id: 5260
  
  9 `* ]& f# R9 ]( E- Q6 Z5 Y
• 
  6 f; X. z8 `/ E: p  p& i' P
  $ t- H, Q$ J2 }0 h  \--------------
  7 [+ ?( B0 Q7 k- r9 D  d0 A# s
  1 \# n* S( u2 D% B, R% }
• 
  # @  I( Y0 P# U6 `3 g
  1 w- w) ~# c, U: s/ l+ k, j) V这里是  Process-3
  
  
• 
  ( Z9 q6 v  k( P( a
  模块名称: __mp_main__
  7 J1 J8 W5 q9 V  U/ H
  1 r) j6 l  d8 q" `8 @% W
• 
  / c8 x- U  Z0 [$ L
  父进程 id: 880
  
  6 \# K: j* X4 Z" S9 Q8 }& k  i. O
• 
  
  当前子进程 id: 4912
  & p8 H5 b/ `# S' w: r
  1 l* g1 s5 w+ D5 U* Y  S
• 
  2 }7 G7 J  J* c( ?, }; v$ b
  " F  h/ n" g$ ^# L8 G. w1 T! i( r: k--------------
  
  
• 
  5 Z) `$ [+ [) |5 r8 `. F# d2 Z
  + n3 v) C+ z5 d  _! D这里是  Process-4
  & H: y: A% A; b. h3 N
  2 k; w8 ^% Q) L7 S
• 
  1 v9 _4 i8 z0 K$ V2 `, k( O
  模块名称: __mp_main__
  
  
• 
  
  3 C: U# u0 S1 v' }# F父进程 id: 880
  
  7 t% W! J/ k' y" i: t
• 
  
  当前子进程 id: 5176
  
  
• 
  
  / z) r0 G' e( b--------------
  1 Z7 w7 h: {; h/ C6 |% [
  
• 
  & A7 ^) T% [+ @! }
  3 {  v  r+ k& m1 ]! H4 E( z这里是  Process-1
  7 y9 Q% S! q+ k( F# [' h
  : g4 I3 ]5 {) M+ @) F& Q* E
• 
  7 d: q+ V* r) M2 p# F0 j% H
  模块名称: __mp_main__
  
  
• 
  " H. E4 G( [& U! X+ J% U
  2 B: }! I0 z* @父进程 id: 880
  ' J5 I: P& Z& W$ Y# ]+ ]
  
• 
  3 S1 _" F: I. T- B
  当前子进程 id: 5380
  & ~" Z& D! Z8 u
  ( E: Q& K% \% h& G! f' U# D9 w
• 
  . m. |$ H; [* m) j
  --------------
  
  
• 
  ' ?4 K' H/ }# X" P
  这里是  Process-5
  
  
• 
  
  * u5 @0 Z" w% T4 a模块名称: __mp_main__
  
  ( r5 c$ U+ Y; O& F# [
• 
  
  父进程 id: 880
  
  
• 
  
  ' O  r/ E* l- ~: v* J当前子进程 id: 3520
  
  
• 
  # c  |- s8 F* K9 z: N( }7 E
  ) H( e3 P% e8 ~3 C7 y4 ~+ t--------------
  
  
  1 D7 X( n' J$ a  Y3 e: `0 M; ^

1. 进程间的数据共享

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

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

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

• 
  4 c3 ^5 ]: r( Z5 j$ o) c4 V( e6 l
  : [- z' \/ z* m. o1 Sfrom multiprocessing import Process
  6 P, n7 `$ t- I
  
• 
  8 N, V3 g" ]) h. K) p
  + Q* S3 |# K$ K- q: r, |; F+ w
  1 F- {" T) C. e7 t: N3 F& l
  + z" B% L; i5 G% S6 }# e& A, a
• 
  ' Z* h4 N) s6 i" P
  lis = []
  1 N+ K$ z7 K2 P# ]' ?' C
  
• 
  , X) s4 |% ]7 ~" f
  
  
    F* }& @" r7 F0 e
• 
  & ^8 w9 l, _$ g# u& e
  + ~- s+ J7 w0 G0 H7 [' V& S$ Wdef foo(i):
  
  # l* J* U4 t0 T0 `' J) d
• 
  
      lis.append(i)
  & a, `/ I& k+ n% a* D
  " j& f6 r! H7 }* v
• 
  9 N& S- i" c) Q: q% F
  - j5 o4 E1 k; y" n; }, c- X    print("This is Process ", i," and lis is ", lis, " and lis.address is  ", id(lis))
  
  ! @, U0 e; `  H$ Z/ z0 [1 q9 R- o# Z
• 
  8 ], H; Y' j* h- f, |% O
  
  
  
• 
  0 f( b% V9 ]9 q7 `$ U
  ! F! w6 q1 t+ R' @6 n1 Z% V; Yif __name__ == '__main__':
  
  
• 
  $ ]) V# g" a) V; V% z6 [6 C" _
  7 ^8 o$ g1 a" u& n    for i in range(5):
  ! }& T6 E8 d$ e% B
  
• 
  
          p = Process(target=foo, args=(i,))
  
  # M# _/ B+ m: [, |* p! {
• 
  2 {0 \1 V0 L2 d8 f) y* i
          p.start()
  
  
• 
  
      print("The end of list_1:", lis)
  
  6 T) n9 @) t7 _6 M, W0 l
  

运行结果：

• 
  8 F9 E7 z% o: h# G& y' u/ R
  The end of list_1: []
  
  - x0 z4 ^% k) w3 j) ]! a
• 
  
  This is Process  2  and lis is  [2]  and lis.address is   40356744
  ' W/ {( n: T% ]$ ]
  
• 
  9 @# K- J0 D& V( n. U) m/ r6 Z1 F
  This is Process  1  and lis is  [1]  and lis.address is   40291208
  , s% T1 ?+ D; u4 u7 O
  
• 
  ' Y, Z* I% r+ p3 }0 j/ }
  0 P( R& w# D: a2 b' dThis is Process  0  and lis is  [0]  and lis.address is   40291208
  
  
• 
  
  " Z+ z) _. _1 _! hThis is Process  3  and lis is  [3]  and lis.address is   40225672
  : ~' o6 u% C3 K. [$ E3 C. h2 x
  - j8 }+ j" E: e( e5 B/ S' K6 h
• 
  6 L# M+ w2 ^3 [0 F( {5 o
  8 z9 H/ a2 c- _; ^This is Process  4  and lis is  [4]  and lis.address is   40291208
  
  
  % S+ r0 |0 d4 h/ r

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

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

1.1 使用Array共享数据

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

• 
  6 J" F2 U6 H: ~5 [
  'c': ctypes.c_char, 'u': ctypes.c_wchar,
  
  ! l( a, u; P/ M
• 
  
  ; A5 S. P, e# `: Z1 H'b': ctypes.c_byte, 'B': ctypes.c_ubyte,
  $ R; N+ O/ p+ d3 M: o$ n
  
• 
  
  3 \7 n0 }, v. v/ J' l+ _+ }'h': ctypes.c_short, 'H': ctypes.c_ushort,
  9 s6 ^0 v* F; T& m/ ?; G& ?) _
  % G. q  Z# B: F- j; G) @# R% C
• 
  ' L/ J) x, |& G6 s8 _* X5 H
  'i': ctypes.c_int, 'I': ctypes.c_uint,
  
  # O, w- C3 B9 g" u, c1 V- w
• 
  8 M- b4 U$ ]9 l/ X) ~# t% i
  2 ]  H1 d7 d' v, J6 `: }" S'l': ctypes.c_long, 'L': ctypes.c_ulong,
  
  " M( K' }/ P5 l& t# g
• 
  ) _  \& W2 L' |6 y7 l% h
  'f': ctypes.c_float, 'd': ctypes.c_double
  6 A& ]0 S& T' L1 Y, O
  9 y! M4 m' Z. ?4 f
  5 f7 l& k, o$ Q  V

看下面的例子：

• 
  
  from multiprocessing import Process
  
  2 `" P. O) T" d! b9 @; a
• 
  " U& U3 `# i8 K$ m
  . C& q" K: W0 B4 Nfrom multiprocessing import Array
  , l/ h  H  L% ~5 |( x
  
• 
  
  
  8 B; E3 v/ b( \, i( i: I
  7 V1 L7 f, K2 I  ^
• 
  
  9 e6 E' U* N( F. [6 o7 h/ H3 |def func(i,temp):
  / |! g# P; M- O: p' `: M' g
  / ?( i6 \8 o1 a5 u- V2 f( S9 d
• 
  6 F" F( x0 Y& d- Y' l( W
      temp[0] += 100
  
  ) r9 e* T2 x6 x5 k% O: C6 y5 i
• 
  
  2 K$ w, p5 F1 U/ Z" H4 B( D    print("进程%s " % i, ' 修改数组第一个元素后----->', temp[0])
  / b4 R" i. a* v3 M$ {
  
• 
  
  " T7 i5 O: E0 I" g, ^+ q
  ; g8 [# v; x( O( M4 X; J
  
• 
  
  ) \- X7 y; ~$ T( R9 k( ]2 Tif __name__ == '__main__':
  0 s6 ]/ t( J1 R+ l1 U6 i
  
• 
  
      temp = Array('i', [1, 2, 3, 4])
  0 U1 T1 h% ~6 {8 D% U7 ^  p
  
• 
  
      for i in range(10):
  & y2 U0 n. U4 ?4 U' A: I
  
• 
  
          p = Process(target=func, args=(i, temp))
  
  + V# J: B/ v  }. e( z
• 
  1 H( |5 `2 y# n* T
          p.start()
  
  8 e# _1 ^: i- d& Z
  8 a: A& K9 b' `) E% h& b

运行结果：

• 
  ; r; O$ g7 c/ }7 }0 e
  % y% n( d$ \* Z* Q1 g; @进程2   修改数组第一个元素后-----> 101
  
  
• 
  ' G: v* ^' g! ?9 ~" b$ n. o3 H% U
  * u3 o9 d+ A' U! e- S6 |# U  {进程4   修改数组第一个元素后-----> 201
  
  
• 
  & R: m7 `  B1 L0 d8 g# k* V: X2 [; \5 @
  . q/ o% J7 p5 Q1 ?0 y0 G进程5   修改数组第一个元素后-----> 301
  
  
• 
    N0 ~  ~0 l3 ?3 n) N
  2 W+ W/ h' j$ {1 d. M进程3   修改数组第一个元素后-----> 401
  
  
• 
  ) u; _) e) k0 e6 w8 d" J4 X8 R
  , y% A* A9 {7 y进程1   修改数组第一个元素后-----> 501
  
  
• 
  ; s1 S3 {# k) z5 }8 F
  & X  i9 L9 k0 w" b进程6   修改数组第一个元素后-----> 601
  
  % e4 T$ C0 k, l' [9 P* C8 K0 N
• 
  
  进程9   修改数组第一个元素后-----> 701
  
  
• 
  7 p/ h) x6 X2 l1 i; I
  ; B: }$ C' Z3 }7 B; X: M2 i进程8   修改数组第一个元素后-----> 801
  
  7 I" {0 O0 C' q; {- U! p
• 
  5 p- Z# t, [- u# W' w
  % G- g) A  u6 l7 B5 w2 d进程0   修改数组第一个元素后-----> 901
  
  ! D* k: N; p1 G; h# f$ L* x
• 
  " U# f; G  p% y: e9 F# q' \
  ; C9 i( R6 z- W1 U进程7   修改数组第一个元素后-----> 1001
  0 q, A% R  @! M* ^: m1 S$ x- D
  
  

1.2 使用Manager共享数据

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

• 
  + j1 D- w7 u! r) Q
  from multiprocessing import Process
  ) h' r6 f5 Z" Q7 k/ P& S6 a
  
• 
  
  5 E: H; t+ x$ ?8 b% Y$ [1 W& Q8 ]from multiprocessing import Manager
  4 d. q* |4 |7 v2 U! U& M: j) x
  
• 
  
  
  
  
• 
  
  def func(i, dic):
  2 d) R' _; b( g3 D& h2 M" l
  
• 
  * y) T; Z, i  `$ t8 u- v
      dic["num"] = 100+i
  % L% H, ]0 c) n5 W1 ^
    U9 {) c) @* H
• 
  
      print(dic.items())
  , m4 j7 Y+ }' U  H& i3 K
  7 D+ i# J5 |) p2 \
• 
  3 H/ V! n- P: W1 M0 ]9 U
  
  
  
• 
  
  . d" F9 S6 X0 z9 ?9 ?if __name__ == '__main__':
  
  , R5 I$ Q/ d' ~2 @9 t) t0 q
• 
  
      dic = Manager().dict()
    {" g) s7 k+ ~5 m
  
• 
  
  * R, Q  q7 @* ?2 w9 q2 B    for i in range(10):
  
  
• 
  8 ?! x+ z' {6 k/ k" R
          p = Process(target=func, args=(i, dic))
  0 I2 p  N2 }' C+ G- a
  
• 
  : o. [: w5 i7 ?9 G6 m( ?
          p.start()
  8 `1 u9 S8 z, q! n5 f
  : f9 o. {( L6 q& {8 ~: y
• 
  : h% q/ F+ |( B" X* w
          p.join()
  
  
  

运行结果：

• 
  8 N* r6 E9 y- I) r
  [('num', 100)]
  1 J; F+ f& n, C2 a: ?4 P* ^
  
• 
  % C2 ]" g/ `3 A/ n
  [('num', 101)]
  
  
• 
  
  ; H; M$ L" X% I[('num', 102)]
  
  
• 
  
  [('num', 103)]
  3 E/ q( b7 a; p  l# [$ N4 K
  
• 
    h, c# e: A* z
  [('num', 104)]
  
  & K3 Y) R; c2 ~/ S7 z! {
• 
  
  [('num', 105)]
  ) \4 t- N3 z) v9 Y( I$ d: P
  - g: `0 M- @4 H8 W
• 
  / `, l$ h$ H7 u
  2 Z0 E8 X! g- U6 n) c[('num', 106)]
  
  
• 
  % Z! V0 @7 l3 O$ j
  [('num', 107)]
  + O% [* o- r9 y0 Z( R6 D
  
• 
  , ]: {$ s' y6 b7 e
  5 f: |3 Q6 y1 A- P+ d) j[('num', 108)]
  ; s* o1 L& I9 T- T$ I1 u; r( V# q
  
• 
  
  [('num', 109)]
  
  
  

1.3 使用queues的Queue类共享数据

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

• 
  9 l: `1 W7 b  w
  9 r2 P: D: {) d6 i( m# t8 z$ yimport multiprocessing
  7 W% _% R) b8 h' T
  
• 
  
  from multiprocessing import Process
  5 U% L% w. S. a2 [  f2 v: `
  
• 
  
  from multiprocessing import queues
  
  
• 
  
  
  
  
• 
  7 `! c5 p! \8 ]1 d
  5 D" a* @/ I+ }3 P0 mdef func(i, q):
  
  
• 
  
      ret = q.get()
  
  
• 
  
  1 I0 [0 o3 t/ {    print("进程%s从队列里获取了一个%s，然后又向队列里放入了一个%s" % (i, ret, i))
  $ [' E: L! h; H, c  K
  
• 
  
      q.put(i)
  
  
• 
  
  : a! S1 s5 f0 N7 e0 }0 p& n# \
  9 p1 x* q: [6 o" q5 {  [
  
• 
  9 e, s& }+ Z1 W
  % F% S0 }8 H7 i, Z- [if __name__ == "__main__":
  
  
• 
  ) [. T; d4 P1 {/ j* e
      lis = queues.Queue(20, ctx=multiprocessing)
  
  , n% R4 r/ l9 g% E) t, x+ P
• 
  
  & f$ C6 {8 ]: H3 M    lis.put(0)
  
  3 m" c9 e0 _2 V1 i  _
• 
  ' X" O1 b6 m5 R' F
  $ i5 l/ k4 |$ @    for i in range(10):
  
  
• 
  
          p = Process(target=func, args=(i, lis,))
  * Q1 ^* i) @6 v8 u: L8 ^1 E
  / X0 B# O1 a7 J
• 
  $ `9 ^1 q+ ?) X" G$ E& B4 \
          p.start()
  9 b) d# C6 t5 F6 s2 B* A  B3 y
  
  ( F. n, z% G- F6 p1 s, \

运行结果：

• 
  0 W- [- i& L) C
  & G. l: ?4 L. ^% q- Y1 M进程1从队列里获取了一个0，然后又向队列里放入了一个1
  ( ?0 `8 i0 W4 K: b4 {
  . ?9 `, P, `9 p; w2 F: X
• 
  ; k! ?: R  S& G' D" H3 R
    }) {* x1 q7 O$ Y进程4从队列里获取了一个1，然后又向队列里放入了一个4
  
  
• 
  
  进程2从队列里获取了一个4，然后又向队列里放入了一个2
  
    ~2 d8 |' h0 [& a/ G0 @# a2 z. ~+ }
• 
  
  进程6从队列里获取了一个2，然后又向队列里放入了一个6
  
  
• 
  : l2 p/ @( `; D+ @
  4 M0 D0 b- j' F% A进程0从队列里获取了一个6，然后又向队列里放入了一个0
  - ~: z! x. P* b, ^% P5 @& S) F
  : W" T( O% E  X' \+ h
• 
  ( U* @4 o: P. M. A
  进程5从队列里获取了一个0，然后又向队列里放入了一个5
  6 R& S0 B" Q6 l
  " l' y, y, z& S% m7 u6 r
• 
  8 X( E% z1 Z' L2 e7 [' o7 v. U! }
  进程9从队列里获取了一个5，然后又向队列里放入了一个9
  ) \0 k8 i2 o/ Q5 \/ @
  1 z; R# A+ o' y3 I$ H/ V3 W. o, ]
• 
  - z. X" f% |' Z& X" i
  进程7从队列里获取了一个9，然后又向队列里放入了一个7
    p' u2 n7 A, w- K9 y
  
• 
  
  进程3从队列里获取了一个7，然后又向队列里放入了一个3
  7 J1 N- u& ^/ N9 U1 m% F) j
  
• 
  ' C2 B) r5 q4 x# l% m! y
  + {& W* A; o. G9 o: k+ p, g; Q进程8从队列里获取了一个3，然后又向队列里放入了一个8
  1 w. V0 ^2 W( `8 W" u4 c
  
  

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

2. 进程锁

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

• 
  
  from multiprocessing import Process
  3 g) }. @! b! `' t& J; j
  3 I* X9 {. I) A1 c
• 
  $ V) h. j4 `; {6 O8 B
  from multiprocessing import Array
  
  " G3 Y0 I, ~% Z# D, m- A
• 
  * e! Z% n1 P! v7 i! l% O) s
  from multiprocessing import RLock, Lock, Event, Condition, Semaphore
  - Z3 w; a  l( f1 q
  
• 
  
  8 ~0 N; y' L0 N# \5 A: C/ Kimport time
  # n5 @7 Q$ Y# V" O! C  P
  2 O/ ^5 o9 E) ]0 Z) s
• 
  
  7 z9 V6 G% L8 o: w
  
  2 t) d# r/ c5 h$ b- p+ |' Y8 Z
• 
  
  def func(i,lis,lc):
  
  % ]' {1 s- @3 f; v
• 
  
  # T- R& t+ i1 C' m) j! a! e* s    lc.acquire()
  
  + \$ D( P# f/ ~7 Y
• 
  
      lis[0] = lis[0] - 1
  
  
• 
  ' f2 w( H! E. i9 a
      time.sleep(1)
  , ~: i' q/ V1 Z# V3 }- ]$ O
  - V$ b/ Y9 z0 |8 V) P
• 
  
      print('say hi', lis[0])
  
  
• 
  9 R2 y9 t3 Q1 `) D1 b
      lc.release()
  
  
• 
  
  
  + A; S1 I  e6 H  d* l5 C, {. Z5 I
  
• 
  
  if __name__ == "__main__":
  / `+ Q( C" d% G; V# k5 y) d
  9 K7 e. o- t: U  _, I
• 
  5 R- G* e8 ?6 A3 U
      array = Array('i', 1)
  0 ]/ N" F8 p! T% o9 n7 y, L
  8 I" q  D! b/ L9 x
• 
    e# V" O7 j- Z
      array[0] = 10
  ) W% _# N  D% H! M& {
  , w3 c" d) h8 q; m0 f% m
• 
  
  ' {2 Z5 V! G- y" t1 Z) |; H) x    lock = RLock()
  ) D+ U* i8 o; m# w0 {. C
  ' [+ P: i  x2 F) P9 @) h
• 
  # ^6 u+ \# q! g% B- t+ j3 L
      for i in range(10):
  . w: S4 a( M6 p) D
  ' k2 d2 G" \9 A$ @0 s! j# y
• 
  - a* j# s, Z" S( V6 m- Z" N$ u
  - r& J5 Z, A& b6 {" Q/ {        p = Process(target=func, args=(i, array, lock))
  
  0 W' e  X0 t/ P1 Q& x: O  x
• 
  8 G7 X. ]$ K6 r1 J* [5 j
  5 \# Y' f/ ]& p! P3 x0 j        p.start()
  : b* t1 {& `: Q, ?( ~' V' K1 V3 A) A
  8 y# ]9 H: D5 N5 `, i
  / q/ _3 C! V1 E6 I* x

运行结果：

• 
  ( p* o# l! T# y* H% m$ l  }$ U& P
  say hi 9
  
  / s. {3 H; I9 D: u
• 
  
  say hi 8
  . T. Z* D) I! U- u$ t0 ?+ v* S# ]
  4 ^$ W# z& b! F! R, K8 d8 u
• 
  , w/ Z0 I! W3 R
  say hi 7
    P/ q! T# {7 r. I! o0 F: ]
  
• 
  6 O2 ~( i9 r% \4 u& \' t
  3 U3 x: e) k4 b. P. E1 Z5 b8 Vsay hi 6
  
  
• 
  
  " w9 ?1 s, R1 S6 N6 |4 ]0 y9 O# C1 L- Xsay hi 5
  
  2 L9 F1 Y5 D6 U. |' B- k0 x1 Q7 r
• 
  : A* W& b& k/ A- W+ r
  say hi 4
  
  & x4 ?- i8 X/ e8 t3 V& j4 {8 M; a
• 
  , w3 j8 r- d* s9 Q6 Z( i- ~8 u- O
  say hi 3
  
  * H9 t$ f4 X0 |( W4 t3 a6 s
• 
  
  2 C4 F# r3 R+ w" Wsay hi 2
  . U3 V4 @0 U0 }. z
  
• 
  
  say hi 1
  ( S9 x* o9 k2 I, O3 A! |- C) U
  
• 
  
  1 s, |7 Q. a- ~8 R/ Tsay hi 0
  
  
  

3. 进程池Pool类

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

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

进程池中常用的方法：

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

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

• terminate() 立刻关闭进程池

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

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

  
  

• 
  
  - d$ C" \: u$ p" m. Ifrom multiprocessing import Pool
  
  6 U4 k2 }+ n: ~* f1 X0 r
• 
  
  import time
  $ T6 a( E# L0 \+ M$ M# |# L
  
• 
  * |) f% ~6 B! h
  % W- r7 ]4 s  b+ j7 G1 a8 [0 `
  3 D9 {4 y% t8 ?/ O3 ]1 o% L6 D4 \" @+ ^
  
• 
  , `5 C  u0 H6 w5 L9 k9 ?0 b5 H
  def func(args):
  
  : {  I: _4 U3 G, w! x* g1 @
• 
  
  ! q- U' t+ ?3 j    time.sleep(1)
  
  ( R% `1 U& G! U* x$ K8 m/ n
• 
  + O* r; ]6 A! H: E/ B7 \/ G$ k
      print("正在执行进程 ", args)
  % U3 X/ R' A/ I# n$ n) r
  
• 
  4 H9 U) ~+ E0 G3 s" A4 _, U& N8 i
  
  
  ) K4 n. M6 s+ F; T- d* X
• 
  ( @% H; l; T& N- H; C% `
  3 d0 u: O. E# Oif __name__ == '__main__':
  
  3 w, F3 m+ k( z  _' A5 t+ J
• 
  5 S# U2 D) L% @" L  M! Y+ m, a2 e! n; o8 @
  8 L' g- ~% @; l. G1 O' G+ [
  
    e/ G4 }3 L8 O! ?; B, S
• 
  
  # S7 _4 ^8 N# x+ L; k    p = Pool(5)     # 创建一个包含5个进程的进程池
  
  " |. u) W: x4 |
• 
  
  
  , A/ d+ U* v( f& \& Z2 r& }
  6 Z' Z: M' J& x# O
• 
  
      for i in range(30):
  9 ?4 ]% |/ l/ s. h: R' l
  
• 
  
          p.apply_async(func=func, args=(i,))
  $ v# @. c7 r2 u" Z# v2 K% H2 ^
  2 U# H' t" q3 Y. `
• 
  
  
  6 P5 G% C* ~' ]8 X1 N
  
• 
  
  ' E% b& R' M; Z# n    p.close()           # 等子进程执行完毕后关闭进程池
  
  $ d# l5 s7 z. r5 V) n2 y1 Q1 L
• 
  0 i  K3 X* I' Z7 Q
  + C& {8 K% u; O1 t/ V- J1 X    # time.sleep(2)
  ! e/ }1 l- |: j1 e9 p8 L
  " I5 q: a+ V# d0 G2 w% ~
• 
  
  2 X; W6 {$ U6 I( a+ s( o4 X    # p.terminate()     # 立刻关闭进程池
  6 X2 |- T1 z0 X
  
• 
  , X1 a9 @, w1 q6 e+ x
      p.join()
  
  ; _7 \9 \, i# S" N1 M9 p% X8 c5 \/ Q+ w5 `
  

请继续关注我

- }1 ~8 m# e) D5 V
7 A2 o) d9 L+ K% r- Z% G