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

杨利霞

爬虫（七十）多进程multiprocess（六十一）
  T4 \9 J0 Z8 ]: m1 f* D

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

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

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

• 
  . a3 L4 L+ K2 S' f4 {" p# I, O5 O
  import os
  
  
• 
  1 w/ w* j8 L  J
  import multiprocessing
  5 n; h! w0 B4 f" z- G$ I, _: k
  
• 
  1 l) I6 ]* m4 q. b
  
  
  ; _0 d' m  B: D& ?1 O* R$ h
• 
  
  : z3 |2 K  Z1 \/ T) U2 s' R; Sdef foo(i):
  
  
• 
  6 J8 K5 W: D2 n* Y- [
  5 {/ u* ^6 O1 H    # 同样的参数传递方法
  - P8 X6 W4 \6 g, W9 ^+ J. `; s
  
• 
  
      print("这里是 ", multiprocessing.current_process().name)
  2 ^& \) Q! z/ `3 }# O
  
• 
  : M- Z3 I9 O1 ?% V0 D: Z% g
  , F1 e5 Q* d) Q% W4 j1 ~0 D: F    print('模块名称:', __name__)
  
  + U+ L' Z% {) {1 o) e
• 
  - ?  l8 D+ X9 J
      print('父进程 id:', os.getppid())  # 获取父进程id
  
  
• 
  / n" h; @- b  S' \5 o2 j( e
  + o: s" s: ^5 j$ `$ X1 U$ r    print('当前子进程 id:', os.getpid())  # 获取自己的进程id
  + w: E. L" T! G8 U& }( P( j
  
• 
  ' g( K0 M5 X$ K1 v1 V
  * W6 v9 v  [3 t4 V3 m$ Z    print('------------------------')
  
  
• 
  & N" Q2 [+ M; n8 r
  6 `2 q3 Z. |4 F  N0 k5 f
  / V/ e+ w( ~* n" R5 p; I6 \( D. ]
  / j: {$ a$ T+ K/ n1 v
• 
  
  ' y" K" y. |  d) `. j, N* B/ iif __name__ == '__main__':
  
  
• 
    i  f1 O* G# f
  
  $ ~' n' }1 q& S; H4 V
  * a) W+ @/ m5 [7 M
• 
  % w1 s4 C8 m0 D# q& F2 |
  2 t/ q7 U" ^% x' B% U    for i in range(5):
  6 `  K0 r5 p  Q+ u& D
  , o7 ], C% ~% D
• 
  
  ; }2 J" B+ k. |& Z% W% f        p = multiprocessing.Process(target=foo, args=(i,))
  6 \1 F* i  b& D, |5 I2 k& s4 Q3 M
  
• 
  
          p.start()
  ) l- a3 V: l1 \4 \# v
  ! ]( h" B3 m& a, I. P' r# y7 |. |
  

运行结果：

• 
  
  这里是  Process-2
  1 w$ g/ G$ }( k1 l- \
  
• 
  - h7 q4 a9 Z% h+ g1 b+ _, p
  模块名称: __mp_main__
  
  
• 
  ' w/ m$ D8 n$ R, c* U8 R. H, ^; `
  父进程 id: 880
  ! ]& i1 @! t% M
  
• 
  
  当前子进程 id: 5260
  
  0 L* t7 Z- k$ r0 c; r9 |4 P: o
• 
  . I) M) _" V2 ^- x' L7 ^+ q8 Z1 d) j
  / y  C& R/ H/ ^' _--------------
  
  / k3 J/ O7 i! ]! g5 T5 a+ v( q
• 
  
  这里是  Process-3
  
  $ R; B# [* O* Y+ u$ G+ S& I6 C$ j
• 
    ~) Y; y" f( F" f$ M3 j
  5 b, v, @2 }8 A1 ?3 n! {0 z5 N, R模块名称: __mp_main__
  
  
• 
  ' S9 O4 [* q: a+ a( ~% b
  ; g& u! q% ^7 I( j: m7 H父进程 id: 880
  ; ~3 {% Q% _* U( y
  
• 
  
  当前子进程 id: 4912
  
  
• 
  . T# y+ R6 U& f' j, N2 }
  " S2 B( S! J0 j* E7 J--------------
  ; b+ N7 A5 v) E; F2 v4 M
  
• 
  ; s3 ^! Z" R. M6 n& I3 e3 f
  / ~3 R$ A: O3 o0 |% `这里是  Process-4
  
  
• 
  
  模块名称: __mp_main__
  
  6 ]- J4 z: q: w  y
• 
  . T- x  I* {5 ~8 l& B( v3 p
  父进程 id: 880
  " S7 K+ {3 P% h
  % s* ?2 V: V- S5 @. `
• 
  % V6 F( w0 T8 L- p) K$ S' c
  当前子进程 id: 5176
  
  
• 
  
  --------------
  + o7 }/ o9 H% I4 D/ G8 q, |
  
• 
  4 B; S2 X# o" H: v  u
  这里是  Process-1
  9 r  s6 g- `/ p5 Z0 B. L
  
• 
  
  模块名称: __mp_main__
  
  
• 
  9 M5 [& |; v! F+ ?' q* E- ^2 L# s( S: `
  父进程 id: 880
  
  
• 
  1 {* c. c) `7 L" Q6 E" K% ~/ L
  当前子进程 id: 5380
  
  3 x; r4 X/ t+ H0 T" O0 |  u; f3 i( {
• 
  
  7 D7 s9 ~( o$ C  ^% d--------------
  
  
• 
  ' k3 [3 {% O! ]  f- `& O
  % s- A' ~) c2 M这里是  Process-5
  
  
• 
  , e* m6 G$ ^# R* b6 C* s5 Z
  模块名称: __mp_main__
  
  
• 
  
  父进程 id: 880
  
  
• 
  
  # V2 a: V2 y0 L" D$ _9 o% D当前子进程 id: 3520
  8 T% k1 {5 {! f! Y7 \2 Z
  % y+ c* q& A( Y  [
• 
  
  --------------
  
  ' h- S& k7 m6 T( n* ~
  

1. 进程间的数据共享

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

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

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

• 
  
  from multiprocessing import Process
  
  
• 
  
  
  
  ; a* D) P* T3 A9 f  z& Q. _
• 
  
  lis = []
  5 S$ T/ c+ t* j9 L% i4 W
  
• 
  0 C8 e8 i* d( g) o+ U+ K- W
  4 o0 \2 s3 }5 r4 C7 V3 s
  . z, f6 ]7 [- D8 W
  ' Q; t1 o/ X- _1 [  @
• 
  / v3 D$ J8 ]! c& X' ~& l. y
  & }4 _; u" {" D! K8 |6 @% Z5 M' Pdef foo(i):
  * G9 m/ a; }+ N$ a" ]5 E- F3 ]. g
  
• 
  * J$ k& v3 ~( T+ B0 G
  8 K- v1 a* ]+ }1 m8 {/ F    lis.append(i)
  
  . q- V' e! M) _  ?, D
• 
  
  . ^" `) e; |/ M    print("This is Process ", i," and lis is ", lis, " and lis.address is  ", id(lis))
  
  
• 
  
  
  
  1 V1 K. L$ m5 p( H
• 
  
  if __name__ == '__main__':
  
  
• 
  : z1 f$ X: d0 ]1 |$ Q. H
      for i in range(5):
  
  5 }; ^# o5 H, H- N' R" E
• 
  % o* I, _2 u( Z8 Z" X
          p = Process(target=foo, args=(i,))
  2 {6 `: I7 x, o9 [. a( S: w
  5 b& ]' w. s6 G
• 
  ' [3 x+ e; y; p( ~9 k4 ?2 M
  - H2 M/ T) A& U7 F        p.start()
  6 J4 i$ n+ ~% s( }2 }$ M
  1 K/ M4 g$ T9 M8 ~4 l
• 
  
      print("The end of list_1:", lis)
  
  ! q- h; @3 Y  H& C
  

运行结果：

• 
  
  The end of list_1: []
  / y! B4 [; W& a, y
  ) x- d1 N+ D0 e) m  T/ _0 k, N
• 
  4 q; b0 O- o2 B( f# }0 \0 D
  7 o2 g/ I, }5 o  l7 u& `* UThis is Process  2  and lis is  [2]  and lis.address is   40356744
  & H& |. J3 M- I7 I; T; A# p9 S
  ; w" l- S& b# O! ?
• 
  
  This is Process  1  and lis is  [1]  and lis.address is   40291208
  
  
• 
  1 V& ~/ x! r4 g" g" D. u
  5 B3 j" D" a9 I+ w; l/ S1 V( YThis is Process  0  and lis is  [0]  and lis.address is   40291208
  
  9 D* ^$ Q. h. U& V4 z
• 
  
  This is Process  3  and lis is  [3]  and lis.address is   40225672
  
  
• 
  " {0 F( V- |, r. F. X4 ?3 U
  This is Process  4  and lis is  [4]  and lis.address is   40291208
  
  9 }- ~! f$ C9 h5 {2 G) Q# F. k( K
  , p5 x0 L6 K. O+ R

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

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

1.1 使用Array共享数据

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

• 
  3 G% t7 x* J) f1 c1 E
  'c': ctypes.c_char, 'u': ctypes.c_wchar,
  
  
• 
  
  'b': ctypes.c_byte, 'B': ctypes.c_ubyte,
  
  % I( U/ T+ ]& i" v/ K# w7 d
• 
  8 J: E& ?( v5 A) Z* |
  3 j/ |& {: B" R" G- K7 e1 B5 }'h': ctypes.c_short, 'H': ctypes.c_ushort,
  
  4 T( Z7 n: q5 t# [3 H- T5 N% E* v
• 
  ' a" I2 M# R7 `# a( G% W/ H
  , q- ^! F# x$ x- `# e. o. h; \'i': ctypes.c_int, 'I': ctypes.c_uint,
  6 _4 v3 j% @0 a( z9 i  }) X& @
  8 V, A9 V6 u/ ]' i0 U9 v
• 
  
  'l': ctypes.c_long, 'L': ctypes.c_ulong,
  4 o" z! @3 O% G" K: @
  - D. w, b, M$ x
• 
  2 l! t8 `$ v" s9 u
  & h% p4 O1 K/ d+ I) W% I'f': ctypes.c_float, 'd': ctypes.c_double
  
  
  ! \9 n. M$ l6 U! n" ^6 E4 L' p& j

看下面的例子：

• 
  8 |  ]2 S0 ~* \, R) Z# ?. s3 r  d
  9 ?* m! S% Y: D" z$ Zfrom multiprocessing import Process
  ) i5 X  j- e. [
  6 h5 L1 m5 }6 L# W1 _. D2 X3 A
• 
  
  ; f& u% \3 A! n3 Q" e2 xfrom multiprocessing import Array
  
  0 m3 e2 g4 S3 a% l! i
• 
  7 t# Q- S4 m  v' D& H" N1 ?3 H
  ' E7 @, q1 u! y! B. v- T9 D4 |
  
  
• 
  
  ! k! e$ B! f: S  K- ]% b: n* E( Qdef func(i,temp):
  # k2 _) V2 m: X8 e0 {; Y1 x
  
• 
  
  6 h) d" Q& \3 ~    temp[0] += 100
  ! \. b: a& g: t8 p7 Z+ c
  ; P; b4 h! S$ k* j7 w: _4 k
• 
  0 X# \9 n# p' @
      print("进程%s " % i, ' 修改数组第一个元素后----->', temp[0])
  5 \& H: h9 T" r  j, O8 f
  , ?' o9 D! n, h6 E0 V
• 
  , \" H, l" Y' Z
  
  
  
• 
  ( d- i) a: R" V! y* q7 w
  & Q, v4 O  a8 \% Z. f3 pif __name__ == '__main__':
  
  & e* B5 O. b3 G2 ]6 W- u2 p
• 
  
      temp = Array('i', [1, 2, 3, 4])
  9 j$ {+ I! |/ |. W' {# v+ u
  ) C2 U, W5 k# N" d
• 
  
      for i in range(10):
  
  
• 
  
  ; E5 }) g7 ?* s, |, ]# e        p = Process(target=func, args=(i, temp))
  & f, Z) u9 y, n
  
• 
  
  1 g& m% Q7 [- C1 q9 W. c        p.start()
  ' S: V; e! }6 m$ e: V) ?
  ' D- _- {- B: x7 d! e8 r
  0 }& v) Z5 }) }1 F$ t# p% l& D

运行结果：

• 
  9 F0 I; y" c0 t. l1 ^' s# B
  ( g; a1 i6 ^0 V% M! [" X% b进程2   修改数组第一个元素后-----> 101
  
  ( P+ }2 \+ Q! N9 \5 r" t. A; `
• 
  * Y+ O3 j2 H9 b4 ]4 \" g) |% O% u- Q
  进程4   修改数组第一个元素后-----> 201
  1 i, Y/ R/ E; j( X+ {
    n9 H+ p. `$ M3 {4 n
• 
  # Z2 [1 H& {! n: q
  进程5   修改数组第一个元素后-----> 301
  ' X3 J: b1 q/ E) `* P8 R# h
  
• 
  
  7 X$ \# M# F7 ]! u9 X1 h( G进程3   修改数组第一个元素后-----> 401
  ' e& G8 R+ {% g' [
  4 d# |( s( J9 ]) A- l: X) v
• 
  6 ~7 V+ j" P: w; t% Q: |# f( \
  8 n: [2 \( E3 _! c进程1   修改数组第一个元素后-----> 501
  
  
• 
  
  进程6   修改数组第一个元素后-----> 601
  
  1 ?' A) d2 w5 `6 h5 T/ H
• 
  ( {7 g6 J  z: M
  进程9   修改数组第一个元素后-----> 701
  
  
• 
  
  进程8   修改数组第一个元素后-----> 801
  7 k# E  `( N) F7 I' u
  
• 
  ) k7 A" U- f& `8 L
  ) Z3 M5 q6 y# l& h进程0   修改数组第一个元素后-----> 901
  " l" _. w/ I; n& Z5 Y
  
• 
  9 v# [! B$ d7 L* I
  1 |& x7 y# T6 f进程7   修改数组第一个元素后-----> 1001
  # _$ j0 v" u0 `, E! @& [" ?, C# W
  # `- S6 R' n! a1 [
  

1.2 使用Manager共享数据

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

• 
  " {: M9 s- R/ x  o0 }" W; _& h1 C
  * D, J. Y3 Z$ @: Rfrom multiprocessing import Process
  ; K& D9 \# C0 q' Y' K' \, R! j
  , T7 B% `$ t* ?% g
• 
  
  from multiprocessing import Manager
  
  4 e5 l) q/ U% Z
• 
  " W5 {, ]( E9 @+ ?9 K5 T
  - q1 J. o3 {" r5 ~. u
  " C3 G: l" E5 N3 ]0 _
  
• 
  
  ' b4 U: b/ T' W1 a. X$ Z1 odef func(i, dic):
  
  & W' _4 Z( D4 b7 a- j
• 
  
  4 h8 t) n& ~: s* m0 ~( d+ I    dic["num"] = 100+i
  
  
• 
  & U+ }# M5 `7 _5 [8 b7 K
  ' H8 \2 }) C( C/ ^4 h    print(dic.items())
  4 ?1 R$ p5 z/ m# b3 B
  % z1 C. _7 \$ A
• 
  
  / W) X6 v' p- d1 b
  ) A3 M6 m1 x7 _, x' m1 g
  
• 
  
  ( ^9 O- n( a/ r, ]+ ^if __name__ == '__main__':
  4 Q' y6 \) n5 J. q
  : P6 W& E) F9 e3 N& t7 ^4 {! m
• 
  " Y8 U  `. a! H0 Z- f0 A- ~: S/ f
      dic = Manager().dict()
  
  
• 
  
      for i in range(10):
  9 B; v6 z% Q* S
  
• 
  / R5 X- ~' K6 W: T* Z' W/ Y
          p = Process(target=func, args=(i, dic))
  
  
• 
  
  4 K& h. [: K2 ~, i& m- w        p.start()
  
  
• 
  
          p.join()
  
  
  

运行结果：

• 
  
  [('num', 100)]
  % E7 H- o. ~9 _3 Z3 j; _
    \$ }. n1 ^0 @, W
• 
  6 z- ^! \) A* ^% T; M
  [('num', 101)]
  
  ' q! w0 d! R8 B5 w9 D$ u9 R1 V
• 
  * U6 c+ l: F+ F$ F! L( H
  3 {% t7 y0 Q) l& H[('num', 102)]
  " w+ v( T  y; ?
  
• 
  
  9 Z) n/ V5 }! W9 q  D[('num', 103)]
  5 a" r- i( Y7 e3 K* S
  1 N+ P: ?+ \( `  d$ h7 H8 D
• 
  ; s: p& L5 f$ f) \. |. o
  + E6 d/ F9 |7 P) z1 J9 z) K9 @7 A( q[('num', 104)]
  
  3 A7 P9 m) G$ C0 ?
• 
  ) C/ W; a/ e  S! V. B* [( @* \# v
  9 N" A9 ^8 X; s' B4 ?[('num', 105)]
  + X, v' t+ x4 Q4 G% g1 c0 K
  
• 
  
  [('num', 106)]
  
  : N& V$ q/ N. z& u0 P, t
• 
  8 y9 w% `+ ~8 I
  [('num', 107)]
  
  1 a. k; o: |6 L% v# E
• 
  
  [('num', 108)]
  1 R) i6 p" j: l& M
  # z2 L# e) t# }% E% R
• 
  
  [('num', 109)]
  ' V9 d" |! g+ f  u1 x! B. I
  
  / k) I. x7 @% f, G1 z

1.3 使用queues的Queue类共享数据

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

• 
  
  / b# U4 e' \) B0 H1 K4 Y) S8 _import multiprocessing
  7 G+ Y* Q+ Q6 F8 D1 Z
  ) e. @! J* Q' {8 }* z6 n
• 
  8 z  Z. T6 y2 ^6 R8 T$ J
  & C( i/ V9 d  M6 Wfrom multiprocessing import Process
  ' u: E4 Z6 [, u6 m" H3 {$ r! ?# D# I
  
• 
  
  from multiprocessing import queues
  6 c# x+ k: T$ u3 |
  + m7 R, _1 Y: r6 V8 _; U! c
• 
  
  
  : s* T3 M0 `2 L2 }5 |
  : m# o( z: o  b! G: Y( Z% P0 }, r
• 
  
  def func(i, q):
  % C- E4 I) P' r' Q' n5 C5 H
  * b/ n. `5 A0 \
• 
  
      ret = q.get()
  " s" H  {6 b- K2 l  B1 @
  7 o( P7 t6 g1 F2 @9 Q- v
• 
  
      print("进程%s从队列里获取了一个%s，然后又向队列里放入了一个%s" % (i, ret, i))
  + J0 g/ p. c; B0 @, c
  3 g7 t4 D7 z7 R, n3 g0 d4 j
• 
  1 V8 B; C( B2 I% f- A. E
      q.put(i)
  
  6 I* ^! ~/ q4 X' @' I1 u
• 
  
  
  - G- A  _7 [- T( g# D
  ( q% |. P, d0 j7 C9 t) C
• 
    k3 r( w  t  x8 Z% g+ J! Q: w
  if __name__ == "__main__":
  0 D) d1 e& {, N4 x. N, y7 K5 E
  
• 
  / s; p/ }. V8 a
      lis = queues.Queue(20, ctx=multiprocessing)
  # p& H9 y$ k6 }/ [% o+ z5 `; ?
  7 A% y( `9 a+ T2 C' d2 D
• 
  
      lis.put(0)
  6 I- V5 _+ D' r8 i5 J
  + t2 P3 t2 m) I& I9 C' J2 e
• 
  
  9 ~: L. v9 `6 T1 H- U- k7 p6 ?    for i in range(10):
  * Y8 @6 j6 H/ R+ {" V# |
  ( g. E6 `; D& b& U4 L5 s8 I
• 
  0 Q/ p. H7 [% V4 n6 X
          p = Process(target=func, args=(i, lis,))
  5 x3 N6 F- P. i( b4 X
  8 m, ?4 c. }/ f# E/ L* r8 o
• 
  
  , s* p" x- G. A* O! {, i        p.start()
  
  % s/ _2 f% g' C" l! e$ ?. A
  1 M0 ~  ?; d4 g  H# X" z

运行结果：

• 
  5 L- @" `# G7 L8 R
  进程1从队列里获取了一个0，然后又向队列里放入了一个1
  
  
• 
  1 o* o: Q: r3 k' @! ]8 x" N7 N
  6 x# P* Q5 Z& g; g( [( Y进程4从队列里获取了一个1，然后又向队列里放入了一个4
  
  5 Y" o5 m: o" \% ^
• 
  * O+ j+ c0 Z+ G& d8 S# }) e
  进程2从队列里获取了一个4，然后又向队列里放入了一个2
  3 z% j; s2 }  j! x' n  q7 U/ U# U
  
• 
  
  % p1 C1 U7 @6 K! \8 e进程6从队列里获取了一个2，然后又向队列里放入了一个6
  / e& @* {: ^8 K/ u/ q" C; S# X
  " h! [# P2 w2 H* Q
• 
  / D$ f4 O" y" r( T0 v$ C
  进程0从队列里获取了一个6，然后又向队列里放入了一个0
  
  
• 
  
    J) t3 G: c4 L4 Q* @0 ^- w进程5从队列里获取了一个0，然后又向队列里放入了一个5
  
  
• 
  
  进程9从队列里获取了一个5，然后又向队列里放入了一个9
  
  ! W# l' H  n8 a
• 
  
  " \( E+ b$ N7 o2 s8 ^' m8 F# e进程7从队列里获取了一个9，然后又向队列里放入了一个7
  
  
• 
  5 c+ t( E- G7 v% L
  进程3从队列里获取了一个7，然后又向队列里放入了一个3
  8 H# \; G  q. B: A! u* c9 l
  
• 
  
  进程8从队列里获取了一个3，然后又向队列里放入了一个8
  / L' s9 L' c4 J/ _6 H. V
  
  

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

2. 进程锁

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

• 
  ; z. D. k8 ]. ?& ]- K  l% D
  from multiprocessing import Process
  , ]: s% K9 O  B8 ]
  1 k; {3 s! Y$ o+ S7 c3 w! \# @
• 
  
  from multiprocessing import Array
  
  % k2 @! K" \  h) V
• 
  3 F3 h0 w" G- ^: S" c
  from multiprocessing import RLock, Lock, Event, Condition, Semaphore
  
  
• 
  8 t$ x; `# A: b6 Y7 m
  import time
  
  
• 
  
  % Q. K. p; @: Z( U
  
  $ d0 o# |+ h' e/ m  e& ^
• 
  
  def func(i,lis,lc):
  6 J* F  ]5 @: N9 ^3 \' L
  
• 
  
      lc.acquire()
  
  
• 
  
      lis[0] = lis[0] - 1
  
  ) x) f' p1 {4 a' u4 V( T. X* p
• 
  - E- D% G! I1 P9 w# K; i
      time.sleep(1)
  / Y! N5 W! Y% u1 U
  ; H' b5 i4 V) p0 ^# h  f* V) p# f6 g
• 
  - z0 Z! P* r6 ]4 X$ {
      print('say hi', lis[0])
  
  
• 
  7 p& z3 v- K  T7 ]& Y/ |
      lc.release()
  
  
• 
  
  ; B+ B2 V# F3 h$ [
  
  2 p, ?- M+ l- Q% M( |# F
• 
  
  ' X4 D- J" I. o* |& eif __name__ == "__main__":
  + x$ {3 P  K+ ^. L9 ~- u9 F
  
• 
  
  ) h6 j5 c% R' p0 o( i    array = Array('i', 1)
  
  7 A* b, P0 w1 n0 R
• 
    r8 _- y+ F$ f! c% q
      array[0] = 10
  
  
• 
  
  * J7 ^& f0 p/ i    lock = RLock()
  
  
• 
  
  2 D" L& [. W# X* Q, ^4 g0 h- ?    for i in range(10):
  
  
• 
  & H) u3 R. w* B& Z5 r
          p = Process(target=func, args=(i, array, lock))
  
  
• 
  
          p.start()
  
  . o" p5 U1 A  u. O: w$ e
  ! a1 E' G7 P8 `5 |0 g/ f+ G& C/ D, `

运行结果：

• 
  / I2 b# d2 z( S9 N2 B' F. r
  9 J1 T1 `* k, t3 v1 Q. Bsay hi 9
  # C- M( R1 s" S: U$ @. [6 v
  " U% I5 g) n& s# S
• 
  
  2 I  d" s; J8 ?1 V/ U1 ?  `say hi 8
  - y7 g. `# v' f0 x# j
  * H) k1 l2 e% o; b! [: y6 z
• 
  5 R8 b$ N. o3 {/ w) k0 ?, n3 b4 Q. i
  say hi 7
  
  # `& f* m# w5 {  ]
• 
  ' d4 ?6 x0 c* ?* S
  say hi 6
  " C# L: a& q, l9 _% t6 v
  
• 
  
  $ n( c3 U1 q% x. v- }- h; wsay hi 5
  
  - M2 d* X% ^5 M: `
• 
  8 i2 D) W: j3 `- v
  say hi 4
  
  3 f& ^& G+ D2 @5 l
• 
    y: Y0 n1 n0 ?/ m# V
  ( F4 r2 |& \: h, M4 Usay hi 3
  % r8 ]# V) B$ F5 P  [
  - C4 V0 ]( G# }& g& ^
• 
  
  # i2 r5 Y% w; H9 t8 U, m: J5 asay hi 2
  
  ' b( c2 o  I% @: l6 U
• 
  . J# ^3 Y# ^/ ^+ @3 f  ^
  say hi 1
  
    L' A3 h$ W' b/ P# b! W: @) F
• 
  % {( f! c- H4 [" H3 T5 b+ ~5 a
  say hi 0
  ' \( Q% G( B9 ^! S. a& |
  
  % B( i# c: k9 W) n. C8 B

3. 进程池Pool类

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

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

进程池中常用的方法：

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

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

• terminate() 立刻关闭进程池

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

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

  
  

• 
  
  8 {+ I2 w6 u' y5 O' E* ]. @from multiprocessing import Pool
  
  4 c$ n# T* b7 d0 q' j% }' [
• 
  9 b# B! A2 C0 }$ a
  * S, o+ P8 [" R! ?9 X8 Dimport time
  
  
• 
  
  
  * h+ i' `+ f! w. C
  
• 
  # R! Q! a% [: u0 Z
  def func(args):
  
  
• 
  
  + i  o, d1 _1 a$ p, A" b: {" n" O    time.sleep(1)
  5 d- b- I! ]8 U" M2 O# a3 C/ T0 c
  
• 
  
  & {1 |1 A0 ?% L" g    print("正在执行进程 ", args)
  
  
• 
  7 M  o  v4 V' a' |9 {  O8 H
  ) W* Z/ c& Z9 H- }- T6 ~
  
  : c3 u  _0 A0 n
• 
  
  ' M. p4 y" a8 s2 Aif __name__ == '__main__':
  4 p# t  i2 A0 ~: ?& t, M' N
  " d7 W+ @3 @" p+ r
• 
  & v- b0 d( w) r1 A% r
  ) y4 S4 E  j* r  {
  
  % f1 P% v9 o. ?2 R0 g
• 
  3 m. l4 }1 K9 s0 e8 {: o+ D% V
      p = Pool(5)     # 创建一个包含5个进程的进程池
  ' e* A3 h! U/ p1 W- Z
  
• 
  
  ( D$ G8 f( c: P3 n
  
  6 V6 h" f; a. H3 o  O
• 
  
  & v2 f. S# Z9 L0 M    for i in range(30):
  
  
• 
  
          p.apply_async(func=func, args=(i,))
  
  
• 
  - G# L" j% z( K' [9 x3 W8 h2 M; J- t
  
  
  % ?) d5 ], E! c" O
• 
  
  2 G# W7 L7 s' ]9 a    p.close()           # 等子进程执行完毕后关闭进程池
  
  
• 
  ! D5 x, x+ `) C+ [- A, E# G
      # time.sleep(2)
    E9 P2 y+ n6 v9 x
  $ p5 m" e$ M. K! V
• 
  6 L9 `# X9 s$ U. V/ b) j$ v
      # p.terminate()     # 立刻关闭进程池
  
  ' E8 e! G# j% z: h+ b9 F4 K+ Y
• 
  
  - n' x7 k; I9 t4 t+ J8 {2 S% y    p.join()
  3 }3 k" y$ |# O+ l
  
  6 K/ m8 [( T# n* _

# c$ a8 L* c; x3 R! O3 r

请继续关注我

4 v  ?2 [8 V( X4 g+ g