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

杨利霞

爬虫（七十）多进程multiprocess（六十一）
0 \/ I$ ]- C8 a

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

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

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

• 
  
  import os
  $ C$ W0 v- D6 x* N0 c- v( g7 B
  
• 
  
  import multiprocessing
  4 J- j) ~7 s* q. ~& z- k
  
• 
  : n6 l2 \! {6 ~# q* P1 D' h
  
  ! K% r% [$ }( L9 W0 r
  2 R0 |7 q/ a% l, Y$ c" E- \
• 
  % Y+ C" G0 U* V( d0 T
  def foo(i):
  
  
• 
  2 Z: E; z( l* J, Y3 U
  8 K7 k* s% z. y5 f, D3 d& h    # 同样的参数传递方法
  
  0 p' t( M0 `6 w3 u! M* f8 E
• 
  
  9 C0 `) @4 }: _  ]    print("这里是 ", multiprocessing.current_process().name)
  
  
• 
  3 W9 ^- E- j2 x, ^) o
  ! s7 ^* `8 e2 H/ ^) [( V    print('模块名称:', __name__)
  4 o/ O8 N( _4 d
  ) b. y+ @, i2 S) u
• 
  : F$ P+ V/ Z) @$ C& W+ S- `! ^
      print('父进程 id:', os.getppid())  # 获取父进程id
  
  
• 
  
      print('当前子进程 id:', os.getpid())  # 获取自己的进程id
  
  
• 
  
  ( g; M/ t% p2 t% \    print('------------------------')
  1 B- K% J: d% m. t2 m/ D6 E
  : {7 w6 P. J) |: _3 V' s
• 
  9 q4 E' R  g8 K/ Y
  
  & c+ J$ [2 m3 n% X% L3 Q2 a0 L
  
• 
  0 ]; [, J5 A1 z( y6 T: x9 ?
  2 b- B" d, h; R; `if __name__ == '__main__':
  " O5 P' a, D8 J/ Y5 b9 B2 J5 }, J
  
• 
  
  
  6 T! M. ?+ h7 \: {2 B3 z
  " j7 M# o9 G/ V! R! _
• 
  
      for i in range(5):
  . ~' {! W7 }# m" o9 e* }
  / H* l; `6 W$ ?5 O$ |
• 
  
          p = multiprocessing.Process(target=foo, args=(i,))
  8 e- Q$ F" v4 [2 q
  ( j7 X8 d0 H0 t+ Q, t
• 
  9 i* z7 F/ k! k( T5 v; v" j: ~/ _6 e
  + a8 c% t5 j, |. N        p.start()
  
  7 j- {2 @& G  \- q8 V
  / O+ G- d0 k9 y  {5 ^' i

运行结果：

• 
  8 d, Z" A# \* y5 X6 f* J
  8 s1 X; h4 `2 d) Z. {2 Y这里是  Process-2
  8 Q5 C( |3 G( \7 F3 p' W7 i
  
• 
  ' ~2 `, j. F  Y: Z
  ; K8 c+ u9 w" D% }5 E5 B模块名称: __mp_main__
  
  6 m& [% K2 E) W5 S
• 
  
  ; o  N5 ~* k1 E/ V. K  f$ C父进程 id: 880
    P" [8 P4 C2 [8 `+ v& c7 Z: N
  
• 
  % p. a. }6 a4 f7 {8 T* [
  当前子进程 id: 5260
  
  # R4 W4 G  g8 A) E+ a8 s. x" b7 _$ p
• 
  + O; ~" ]% A1 {& ]5 D* d. _8 O
  --------------
  
  1 s: q8 T1 w5 l2 ]4 K' R
• 
  $ I1 t$ \4 j+ C0 i- Q& Z
  这里是  Process-3
  
  . q6 H& B; b+ R, E
• 
  + [2 ~+ P% ?, d- f* m: A! w
  模块名称: __mp_main__
  : g* ^% a( _0 w; \3 R8 r
  
• 
  
  / ]: Y$ e2 w' n( B! s父进程 id: 880
  
  
• 
  - e1 D: S  t4 V3 p: P: {6 B" b. {
  当前子进程 id: 4912
  
  
• 
  ' h3 V: h% {* ^; I
  9 O% C8 k! L7 u, J6 ^* `( |--------------
  7 K1 Z! w- R) W, O" v
  ) o' v8 ~$ Y7 a
• 
  0 Y- d6 E. W% J$ Y' i- L1 z6 O
  这里是  Process-4
  
  ! Q3 J( p: Y) b' q7 [: D3 n
• 
  % l. W/ p8 t% p* z8 F1 a  m5 u
  模块名称: __mp_main__
  ' h8 j& D! n+ W$ s' S
  0 L4 D: d: R- P: q/ Y
• 
  1 R+ h2 i/ X7 f# U0 B( ]2 W
  父进程 id: 880
  4 s. h" y3 q) M' \: R
  
• 
  1 r1 y4 z2 `% o; Y2 ~
  ) g/ n; R# m* i- v1 m( U) c当前子进程 id: 5176
  ( R0 Y& L2 A. c% Q$ l3 B' T8 C$ I
  
• 
  / H$ G$ E' w; o  [" ?
    R* p$ V( U2 d0 Q' y& m--------------
  
  
• 
  
  ) y' E5 n8 c$ H: s) w这里是  Process-1
  ! ^/ W7 F+ i% m6 Z
  
• 
  & l6 t) o! v' M2 f1 A8 o2 A; `
  . r9 ^2 y$ n7 x模块名称: __mp_main__
  
  
• 
  
  父进程 id: 880
  
  
• 
  0 F8 A( D1 O7 M
  % C. T5 E* S6 \# M/ }0 g8 |当前子进程 id: 5380
  
  
• 
  
  --------------
  9 i% e4 l1 I1 l
  * t  z) l. B4 D2 B& K3 Y6 B: ~
• 
  
  这里是  Process-5
  
  0 f0 E4 l( x* V1 L4 m2 c" M5 V% @
• 
  
  模块名称: __mp_main__
  , ]2 K0 A) b$ F! \+ r! D1 h" P% Q0 V
  
• 
  2 ^& g! A1 A# \! d) ^7 O5 r7 z6 d
  父进程 id: 880
  
  4 Y4 y, ~% H0 y, ~! B
• 
  & @2 h- i' y# ~; s5 z- Z% A& O- j
  8 n( w; N( p6 E( F) r4 ~2 a当前子进程 id: 3520
  
  # ]  i4 K( p0 `' W2 \  R1 k( R
• 
  
  - E2 N" Z) j5 k4 I0 D3 c--------------
  / M* z$ d/ v" Y& C  p! C
  
  - z8 N9 {8 n' c( T, g( j8 o

1. 进程间的数据共享

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

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

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

• 
  
  from multiprocessing import Process
  0 L% Z1 b% M* D+ P6 B
  + ]( |$ i- E& o% z; d6 U. L
• 
  
  
  ! e) S  ~" n5 g" i6 `1 D
  3 w, b" T9 e+ ~1 ]6 e$ x3 ?' g
• 
  ) H7 g  v' w9 q/ Y+ m2 _
  : |" q& T1 w0 D! Ilis = []
  
  
• 
  
  
  
  
• 
  
  def foo(i):
  ; q6 E2 ~6 I. G
  
• 
  
  # u8 C, ~6 Z- V+ c  P    lis.append(i)
  
  
• 
  
  ; f7 G5 N/ o& L6 T& ~: }; n& N1 ]$ P    print("This is Process ", i," and lis is ", lis, " and lis.address is  ", id(lis))
  
  
• 
  
  
  
  
• 
  
  : a- q, {4 g! B* dif __name__ == '__main__':
  
  
• 
  
      for i in range(5):
  9 l( n1 h9 q; _* c
  6 L: q6 |9 j6 V2 n. E! T% F3 J
• 
  5 i1 r$ O. S& k1 P
          p = Process(target=foo, args=(i,))
  ) \$ O/ O7 M; F( ~
  * E5 m1 v+ F# n. @$ n% k3 x6 }
• 
  
          p.start()
  
  
• 
  
  . F6 \/ y1 `! U' V# s3 t    print("The end of list_1:", lis)
  
  # L7 e5 C5 A0 c9 T' R
  " Z1 D2 B3 L! ^0 m7 g

运行结果：

• 
  / B( }2 I2 x* ^5 z+ c* }2 E
  The end of list_1: []
  
  
• 
  . H1 m! A# I. W* v) }' a
  " ~1 j8 j+ N+ D& o" 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
  % H- V: j; W) }+ F% S
  0 k. w. d  \* ]+ V, z
• 
  
    _. W  j( \! ?  t. SThis is Process  0  and lis is  [0]  and lis.address is   40291208
  
  
• 
  4 C, u% Q; V: h- d" Q
  This is Process  3  and lis is  [3]  and lis.address is   40225672
  5 R6 u9 ^+ j% f! w
  ! |1 A6 d2 M/ k
• 
  1 Z8 B6 d$ W9 \
  1 O& K- S* s8 j9 hThis is Process  4  and lis is  [4]  and lis.address is   40291208
  7 _4 f3 L  p; b+ I; ~) U- ]
  / N2 ?" F: ?3 n$ R4 ]4 Z. I
  + F. q' ]1 Q5 p4 G" R; Z

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

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

1.1 使用Array共享数据

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

• 
  # f4 c8 S& X0 f6 x2 E/ |" ^4 ~7 V  Q- w
  'c': ctypes.c_char, 'u': ctypes.c_wchar,
  ! [% T+ l/ P: x/ s1 K" P+ _
  
• 
  
  0 p, g0 G6 m4 L* ~, A1 s" m. G. g'b': ctypes.c_byte, 'B': ctypes.c_ubyte,
  
  ! N1 X8 a* G. ~) j
• 
  
  " F* H) I6 C2 ^4 J'h': ctypes.c_short, 'H': ctypes.c_ushort,
  
  " \1 q' u; |+ j: m$ f+ R% U' O
• 
  9 A* P& c  T4 J0 z
  'i': ctypes.c_int, 'I': ctypes.c_uint,
  
  
• 
  ) M: J, U+ Q: u' D2 x% Y7 K( q
  3 ^# c" P$ j& O* J'l': ctypes.c_long, 'L': ctypes.c_ulong,
  
  
• 
  
  1 @( @( s( ^$ n: e& E'f': ctypes.c_float, 'd': ctypes.c_double
  
  ' c$ G; z% [1 f5 C, Y0 a% j8 }
  ) l/ {# ~6 d4 ]# x6 F8 W4 `

看下面的例子：

• 
  0 `  n/ M9 B+ I* s
  from multiprocessing import Process
  
  - V. _& @' i7 ~
• 
  
  4 ^# }3 O. o& Q2 B2 U1 L* zfrom multiprocessing import Array
  % m4 Q  m9 W( l! a2 [3 l
  " }" U& k3 I7 W* }. l
• 
  
  
  
  7 o5 r3 A/ T- z( k/ C0 q) d
• 
  
  def func(i,temp):
  
  
• 
  
  + Y. B2 e# h% ^! }    temp[0] += 100
  
  5 ]; y5 |! i8 i
• 
  ; Z. i" n% c2 g
  $ l2 b* J/ E, X$ w3 V/ v    print("进程%s " % i, ' 修改数组第一个元素后----->', temp[0])
  " E9 v# k, S! y  I* d
  / f% Y* a$ N1 u2 }) g
• 
  
  
  
  
• 
  
  0 B9 L$ |8 P/ g/ S7 }# W- @; w9 Cif __name__ == '__main__':
  7 \* w, ]+ Z; }7 }9 C! M' p$ u& C
  
• 
  & p! z2 N+ X: l6 ]; K$ [
      temp = Array('i', [1, 2, 3, 4])
  3 m& W- ]- R7 q1 m( b
  * P% y8 ~- f/ A# \" {6 ?6 g+ C
• 
  " E6 V" V  O6 K  ^
      for i in range(10):
  
  
• 
  ' E; p- o! h: n1 \
          p = Process(target=func, args=(i, temp))
  ; r# t0 R! {' Q5 ]
  7 J- f' ]: x5 z" t; D
• 
  
  : D! H' w( V/ T        p.start()
  
  
  

运行结果：

• 
  
  进程2   修改数组第一个元素后-----> 101
  ) X6 ], I) s# o6 k4 P; @) L
  
• 
  
  $ U+ O  A4 Z% J8 y0 _8 m/ `进程4   修改数组第一个元素后-----> 201
  
  2 c- A* o6 X; o- e+ j9 @8 p
• 
  
  % e8 G  G4 x: m' c/ V! n进程5   修改数组第一个元素后-----> 301
  4 q2 f& M! p# }* `
  6 }$ ?( k6 r3 L6 s
• 
  
  进程3   修改数组第一个元素后-----> 401
  0 z2 R% X7 J$ j3 |
  
• 
  
  & ~- w  D4 I2 I" Z6 l, s9 q1 O进程1   修改数组第一个元素后-----> 501
  / q" E8 w; T" U; v% V% ]
  9 G2 l7 f6 f$ w, D" M
• 
  
  进程6   修改数组第一个元素后-----> 601
  + I7 `+ N' W% X" [* Y5 Z- q
  1 q2 {. L* O# q4 i- h" c6 {
• 
  4 O& f+ {& M$ N( |- h
  进程9   修改数组第一个元素后-----> 701
  * H  W- J7 ~+ l
  5 L) o" a  ?! s3 X4 K3 B
• 
    x$ O$ _5 p# F  v: c
  ( V- ~2 X+ j6 y9 G$ g进程8   修改数组第一个元素后-----> 801
  
    I8 i# R" j4 z1 O; R5 ]  h
• 
  5 t& {" ^) j+ N  F+ d  Y* W
  进程0   修改数组第一个元素后-----> 901
  % g7 ~0 E2 @5 i
  3 ?, o0 _; a" z
• 
  3 V  S6 a: \' B- m7 _' \
  5 e- n- n' p+ z0 U进程7   修改数组第一个元素后-----> 1001
  
  % |+ P8 Z' \+ y& R0 }3 Z6 \9 t
  - B. g/ Y$ A1 V

1.2 使用Manager共享数据

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

• 
  
  ; _  p; u4 ^! Q% ?1 wfrom multiprocessing import Process
  . x9 {. ]  t) l- \+ L; L, p& O
  1 H' l" `1 ~8 `$ ]% H6 E- D
• 
  
  * j- k6 [6 O: Ufrom multiprocessing import Manager
  4 _: I& E+ ^# b2 q7 N
  % x: Z* J7 U& r3 f( F; t/ U
• 
  % Q6 r0 ~8 N( B' [* o% q' n& S
  3 {) I1 g1 n" D; o1 q6 \, [
  % {2 @& t8 i, k8 A  n0 B, x) r, u/ H
  , t  q( K* F8 {7 f  j% K
• 
  
  def func(i, dic):
    ?* M" H$ q5 L2 }9 c* B
  
• 
  
  ' n* \8 ^, `; D/ Y    dic["num"] = 100+i
  8 b, F1 x$ S2 z$ `. n8 i
  
• 
  
      print(dic.items())
  9 w7 R9 U+ a6 L, Z& a. N
  . H2 B6 \9 J# {6 j: M
• 
  
  
  ' X* j+ U; [2 d- O! p
  
• 
  
  if __name__ == '__main__':
  9 H0 d4 U, d0 x% N4 n; ^
  ' c) q+ t, u& [- C- N& ^% e0 G7 J- i, V
• 
  ) p: R7 R8 [/ o7 W, u5 k. H
  & o# J5 a& V6 r    dic = Manager().dict()
  
  
• 
  
      for i in range(10):
  ) C) c1 _1 u2 D( L3 Z! E5 R6 Y
  $ a$ U% }6 \5 P1 O
• 
  
          p = Process(target=func, args=(i, dic))
  
  4 c! v& g& `8 `, L7 a- u/ i
• 
  
  9 I3 E& t+ v: E* T" L( j        p.start()
  6 V. L+ E6 Z" U4 d/ Z* C
  
• 
  - J3 b1 {# W/ A
    C3 D- S1 G5 m  u5 h6 Y        p.join()
  & g2 Q7 x! h. Y2 b& Y; U& l5 R9 z
    ?: Y! D& O. j6 ?9 P' i
  ) @) _9 q9 b& U  d

运行结果：

• 
  $ p8 r3 D8 q! A
  [('num', 100)]
  $ h$ a! ~( u9 d, l6 w: L! k
  9 J4 ?$ {; v8 F" [9 @2 {# E
• 
  
  [('num', 101)]
  
  ; r) u+ ^$ C# P+ \0 d( [; \4 r# _
• 
    p2 z( X; I# `
  [('num', 102)]
  
  
• 
  
  * B$ P* P9 l, y4 W5 a3 L[('num', 103)]
  
  
• 
  
  [('num', 104)]
  1 R7 ^& g; d5 j, h# p& b* x7 T# m
  6 o, K# |  _# w/ D' b9 a% z4 M
• 
  
  [('num', 105)]
  
  ' K+ ^( C# o' G% \6 F3 j1 F
• 
  
  " q- u" W( B; n" E! l/ b[('num', 106)]
  
  0 p. Z- B! z0 m! t6 T
• 
  ' B6 q" d2 q- u6 a& x& L- V
  [('num', 107)]
  
  # ]9 Y4 R- d) c" m5 d
• 
  3 j0 C# a9 T* O2 ?- j
  [('num', 108)]
  
  ! d/ O- Y( O$ W4 ^: E
• 
  ! M8 F3 |2 O9 u" J* N' a$ e
  [('num', 109)]
  
  " h8 o  t6 R9 j7 u) e' c3 X. l0 l1 |
  , E/ Y6 b9 m% V1 A

1.3 使用queues的Queue类共享数据

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

• 
  
  : V' k- k- n3 c9 [4 O6 G7 o! [import multiprocessing
  7 G! @5 o1 h+ {- W& p+ }+ r
  
• 
  & E) b, z3 A% h. p; R
  6 Q# l# x8 W9 Sfrom multiprocessing import Process
  
  
• 
  
  0 C! s3 O9 L  Z# t6 s: x3 w7 u- Hfrom multiprocessing import queues
  9 Z& H' G) I/ r/ S
  
• 
  
  
  
  , r: W' u2 v% c; n4 \9 @& o
• 
  * P( i3 m# a$ r6 f& h" v4 o7 Z
  def func(i, q):
  8 _2 Q0 J. B1 \* u- c: j0 U
  
• 
    {9 Y3 f+ j0 q0 P/ c
  / u( k7 ?( J; t% X% C    ret = q.get()
  ! s& `2 ?: {1 j
  
• 
  8 ]- X/ e, B) [; ?0 Y
  8 {2 E9 F* l! L/ G! {! M    print("进程%s从队列里获取了一个%s，然后又向队列里放入了一个%s" % (i, ret, i))
  
  
• 
  
      q.put(i)
  
  
• 
  : O- N, n: U8 j# V! N4 C1 q
  
  
  
• 
  8 w- h$ C" b. m" v- `5 p: o
  if __name__ == "__main__":
  
  
• 
  # n2 O4 g; X% ?& h6 B# D
      lis = queues.Queue(20, ctx=multiprocessing)
    x' u  x5 N0 Z& p
  . r- v2 R/ ~& N
• 
  # t6 K* u9 G$ e
      lis.put(0)
  
  $ @' w# ?% r; D7 L9 Z. n: L1 S% {
• 
  ; \1 U) _  m1 t/ x7 W0 b+ p  n
      for i in range(10):
  
  ' Q/ m% K% V/ F  S; t: v* A
• 
  3 A! a4 r: }4 a" a/ p% _
          p = Process(target=func, args=(i, lis,))
  5 _! N; R# @. }8 g; A
  
• 
  - n4 Y5 r) n! I$ ~: q0 d' D) n
          p.start()
    D* p3 a; W. O' q3 J) ]
    s; N5 ]7 P6 w/ Y# y  P
  

运行结果：

• 
  
  ' c( M5 S# Q9 ?; W进程1从队列里获取了一个0，然后又向队列里放入了一个1
  
  
• 
  
  进程4从队列里获取了一个1，然后又向队列里放入了一个4
  7 u+ ?6 ~1 G7 |0 d7 e9 O
  
• 
  
  进程2从队列里获取了一个4，然后又向队列里放入了一个2
  
  
• 
  
  进程6从队列里获取了一个2，然后又向队列里放入了一个6
  / }# L! L( O6 m2 e
  % g: y  w/ n: d/ _
• 
  1 d; K0 E0 o% N: F
  5 G: J0 }" R9 {进程0从队列里获取了一个6，然后又向队列里放入了一个0
  
  
• 
  
  2 J- T4 p# _6 l4 L% r& s/ |进程5从队列里获取了一个0，然后又向队列里放入了一个5
  
  
• 
  
  0 b$ H5 t+ a6 V: D: V& t进程9从队列里获取了一个5，然后又向队列里放入了一个9
  + |) A% o1 d: g; U7 a
  
• 
  
  4 ?) \% q3 x# S! `" Y& x进程7从队列里获取了一个9，然后又向队列里放入了一个7
  
  6 Y# \2 \  m3 W
• 
  ) M4 a* I+ {- y
  进程3从队列里获取了一个7，然后又向队列里放入了一个3
  / z; o" k& n1 n
  
• 
  ( p+ g. T0 E3 ]2 p# t5 l; z& f
  进程8从队列里获取了一个3，然后又向队列里放入了一个8
  
  
  

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

2. 进程锁

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

• 
  / d) O- `# h) M2 V" g+ e$ ^
  from multiprocessing import Process
  5 n/ e  K" A' w, J6 v
  * B% r9 K" c0 I4 @
• 
  7 N# U0 c- X' b: C9 e
  6 U. A  A, c2 K2 K& A/ {from multiprocessing import Array
  4 a3 N; f2 v+ g
  
• 
  
  . m" k, M# ]6 i  k' j# x6 cfrom multiprocessing import RLock, Lock, Event, Condition, Semaphore
  * z& s9 n& ~" }- v
  5 i5 d0 w+ A  Y$ W
• 
  
  8 l7 {% k' n6 L/ D1 vimport time
  + c- ]9 O% J( _* v
  ( Z6 e% \1 C  _1 G
• 
  
  7 k# D0 B; u  W: ~0 y
  
  
• 
  
  def func(i,lis,lc):
  
  
• 
  
  ( F( C4 ^$ T; {8 f    lc.acquire()
  
  + a: {4 i8 p$ c- B' h- K
• 
  
      lis[0] = lis[0] - 1
  1 o, X# M- U4 D5 j; G
  
• 
  
  9 E% `8 F4 T+ S1 D* o    time.sleep(1)
  ! u, b  J: h8 ~; F1 d1 I6 ~
  
• 
  : ]8 G3 ?- ]8 ?8 D* i. j: j8 ?, U
      print('say hi', lis[0])
  
  
• 
  : }& h5 G  e& X- g/ j
  3 G2 l' E0 \- H( o5 b+ d3 {    lc.release()
  
  , Y8 ]0 @: h* D, q
• 
  ! ~* L# D$ x+ r  {: |0 z" H3 k
  
  ( }! b9 T  {) T- U* l( {
  2 U4 Y# i! @: ]* s, s, L" s- K
• 
  $ r- }$ O+ z# p, {
  ; i" w2 y! J; @& O" z9 p1 a+ Fif __name__ == "__main__":
  7 }# u- n1 `2 l" A
  4 E! i& D9 i, k/ p; Q/ Y2 K
• 
  ( u# K% N$ t  [% q/ n( P  [& }
      array = Array('i', 1)
  
  
• 
  
  " u: U* \) u/ @7 d2 B: R/ y    array[0] = 10
  : a$ G6 [$ E0 F5 w% C
  # j$ b/ Y$ U2 {, C: k6 R) m$ g
• 
  ; ?( l% K2 c6 A
  % [; }3 F/ q2 P' c) V    lock = RLock()
  
  ( s  ~- h: f$ v- U, k/ S
• 
  
      for i in range(10):
  * H, |2 u; i# R) `5 p- z7 W
  " G: l  c6 f+ }
• 
  
          p = Process(target=func, args=(i, array, lock))
  
  ) R3 L6 b9 `% F$ F0 A
• 
  3 F  b4 V3 g6 }2 P$ I+ d8 p% q$ Z
  8 c1 A8 V  i: }. A5 m        p.start()
  
  
  

运行结果：

• 
  
  say hi 9
  
  0 e- M" {( \# N
• 
  3 a0 \" E" V- j9 H1 J, U8 ]
  say hi 8
  
  
• 
  
  say hi 7
  2 r5 N2 `* _' ^
  
• 
  . W& V2 U9 t/ Y% u: u" H* w+ M1 S
  say hi 6
  
  
• 
  
  say hi 5
  
  
• 
  
  + g. `: e/ X/ k5 o) B3 fsay hi 4
  * [; a) T) f; E2 P2 ]
  
• 
  : m1 p9 M- T5 |9 @. o
  / u6 w4 s# {! usay hi 3
  
  . ?% C( Z4 x6 w! \0 u
• 
  & V2 T" I  N( o( h) A
  say hi 2
  
  
• 
  . v$ f6 H7 s: c* y6 r
  say hi 1
  " ~& B! h( \  Q+ f. N  e
  , m: Z, Z! {6 v$ W* z
• 
  
  say hi 0
  " l3 ]/ g  ?# ~% O* c: N" F7 b) G
  9 s! j- K, |. e- L0 t, L$ Y
  : Y: @7 T2 d6 C/ I5 i, `

3. 进程池Pool类

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

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

进程池中常用的方法：

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

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

• terminate() 立刻关闭进程池

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

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

  
  

• 
  . {; P% m6 E. j  q, L
  from multiprocessing import Pool
  
  
• 
  4 W0 ]9 X# I! ~2 J- O' T
  import time
  4 j) a+ b% T- z8 p
  & L. Q2 ~1 p9 k
• 
  ( h" j3 @/ o1 U# {3 a# M
  & z- W' e2 I/ r( ~" y
  
  1 X& o2 {/ h$ Q3 q
• 
  3 k- j% Q9 t" X, W
  def func(args):
  
  8 C; R* p! ?, `, l
• 
  4 f! |; v: u! M* Z& M# M. i
  , _9 O) ~5 t* U: {6 P+ g    time.sleep(1)
  
  
• 
  
      print("正在执行进程 ", args)
  2 e9 C- l3 ^9 u2 q3 G6 w9 Q
  
• 
  3 @1 }  ]+ l' q
  ( |& f* c9 n0 ^5 U+ e; ?( @( g0 c
  9 D* q0 l- s' W
  
• 
  $ K2 J& C1 ]0 A& o6 b
  if __name__ == '__main__':
  
  
• 
  0 m5 R( t2 Q  k) G, X# H
  - ^' W$ D! A6 a
  
  
• 
  ( h' C( v8 K6 R' ~# {' [) X
      p = Pool(5)     # 创建一个包含5个进程的进程池
  
  ) L6 p3 X3 H0 Q5 B: }
• 
  
  ; b3 q' e' C5 d2 M& I9 Q, i& W5 }
  8 X7 Y. P* g  X7 V- ?
  
• 
  2 R6 t+ {( B: N/ O, y4 O" j  M
  6 O" U; B# ?/ Z* S# c    for i in range(30):
  * m1 F$ J7 U! Q: ^9 e+ N) R# {2 t
  
• 
  
  2 @4 m( x% ], z( n- }. {, Y2 n        p.apply_async(func=func, args=(i,))
  ; W9 Q, A) ]" a" R) @) P
  
• 
  
  & `; B( `* O! Q* B; W" t% B7 G4 Q" k
  " k7 t: Z/ V( \9 j
  
• 
  ( P; h4 R* c! ?+ q' I3 S/ w1 p
      p.close()           # 等子进程执行完毕后关闭进程池
  - L  z2 b! K' O7 ?
    s* }  \/ s# A( n
• 
  ) f, O; C( l1 |6 a6 J
      # time.sleep(2)
  
  : e+ O( w' V; L' f
• 
  ' J! o  M5 J% [! l; R+ ?2 E6 |8 ?
      # p.terminate()     # 立刻关闭进程池
  2 w% ]$ R( H# A, M: D
  
• 
  2 o) g0 v! l% }
      p.join()
  
  # [; ]8 C1 ?# ]3 L$ O
  $ G$ ?' p% r2 s$ ?0 a% I

请继续关注我

$ W2 d( }" w5 b2 w7 T' ]# X: Y