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

杨利霞

4 Y- C6 h4 F1 n4 N) j6 |& g爬虫（七十）多进程multiprocess（六十一）

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

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

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

• 
  
  3 L/ N; `* [1 A! t; e$ _$ Vimport os
  
  
• 
  
  import multiprocessing
  3 y  Y7 L9 x4 }
  , j- W2 n$ ?- Z
• 
  
  $ q$ \6 b5 L# `( f% K3 ?
  : ]7 L7 m  W2 P0 q
  
• 
  9 r6 C+ h+ ?& O: `# F% C$ V$ n0 v# b% A
  def foo(i):
  ; L" S( l; h: E( d
  " x4 B1 X) j* @6 D
• 
  
      # 同样的参数传递方法
  
  
• 
  ( g* y0 @/ O1 |9 Z( X7 q4 g
      print("这里是 ", multiprocessing.current_process().name)
  7 @; c; ]0 w1 D3 w' w3 T' V
  ( g8 h+ T' w5 Y1 o
• 
  
  5 p0 l: X) S+ v6 {4 A* r7 r$ G9 `    print('模块名称:', __name__)
  
  8 C, r8 r" G8 Q: `+ `. Q& w/ h
• 
  
      print('父进程 id:', os.getppid())  # 获取父进程id
  ) y2 _2 L4 a2 g" N
  
• 
  
  4 H, t! C* p9 {0 d' a    print('当前子进程 id:', os.getpid())  # 获取自己的进程id
  " E7 k1 ?0 D  S/ }" T& H# D. X
  
• 
  
    F3 n: S1 X9 A. e6 E$ t- z    print('------------------------')
  
  + Z0 g0 j2 B% I+ _8 N
• 
  8 o5 Z6 Y8 @& U% v7 i
  
  ( D# @. V& _+ t" z2 f/ T
  $ b% s" E3 F; L: C& U
• 
  
  if __name__ == '__main__':
  
  
• 
  
  , B& S8 ^. Q; X  {
  ( T8 r5 l5 t1 a7 I$ Q
  
• 
  6 [5 n. @& @2 G% n. Q* x9 t
  ) K, s$ B' ~7 ~8 ^* V* m    for i in range(5):
  
  0 p9 Q3 @: e" C8 r( i5 L
• 
  
  # t  A  Q) I! |( h  b8 H2 l% q7 g        p = multiprocessing.Process(target=foo, args=(i,))
  
  1 d* b# ?( `0 S* A) ]9 b
• 
  
          p.start()
  + A! n- u9 p9 P) g
  8 D& Q" r3 X, z6 `" ^# h4 `1 j
  - ^6 |4 A" l# K% \7 d

运行结果：

• 
  ( i1 ?2 C! J6 Y( f( C5 ?
  这里是  Process-2
  
  
• 
  
  模块名称: __mp_main__
  5 A2 h: T8 v+ W9 C1 A6 N% G7 Q, Y7 t
  : i4 t- G: f' ?9 v, W
• 
  
  3 [4 H  J1 n& w$ \9 l9 S7 i) j) {6 ~父进程 id: 880
  / I4 M. O: {+ B; d$ y$ F, N
  
• 
  
  当前子进程 id: 5260
  
  - H$ }# v8 d1 w% A& Y4 H9 A
• 
  
  --------------
  
  6 {3 o4 y  M$ |2 a5 {3 l
• 
  
  3 H9 K  U2 `; ?6 c, p8 z& d0 E- B2 D这里是  Process-3
  ) V1 c/ O9 J9 i( G7 J# x* p4 A
  9 f, Y9 C8 w) x# n5 U7 t) h  [5 M
• 
  
  * w: L* H1 k1 R/ y4 s模块名称: __mp_main__
  8 M6 A* C, m: D
  
• 
  4 _% H2 L0 n, c) R& K$ E
  6 `6 l2 m/ f0 q5 U* d2 X' ?父进程 id: 880
  ( I9 `7 v& U# z9 B, E  O6 Z
  ( n" v, V, U: D6 |7 t
• 
  0 Z1 x3 n3 F- ~8 z
  2 l. D# L& R* a6 E当前子进程 id: 4912
    Z9 W* _& ]$ j/ V/ c
  0 J9 H6 l/ o) F4 A8 w: D( @
• 
  
  --------------
  
  * z# y3 b/ H' \6 U3 B6 B( O2 t
• 
  
  这里是  Process-4
  
  7 _) Q! F2 I* t% _- n
• 
  
  模块名称: __mp_main__
  
  
• 
  
  父进程 id: 880
  
  
• 
  0 ^: N7 p. p1 ~, Y0 q) A' a
  当前子进程 id: 5176
  & Y% K9 o( b; `* ?9 q" u# A0 w
  
• 
  
  # ?; O# J* L; l! u0 u1 Z& y+ J) Y--------------
  
    C; h9 U" N5 d0 [' ^/ k
• 
  ( s2 d3 c6 ]& h1 R) H1 Z
  这里是  Process-1
  ! q0 p9 d  g% [9 {' X9 |6 b! E6 V
  
• 
  
  模块名称: __mp_main__
  ' ~1 H' [7 v0 M& @
  
• 
  
  ( y2 a! M6 p+ h% T父进程 id: 880
  2 @2 F1 ^2 W" U5 Q+ L$ A
  " D3 x7 U4 d' G( }
• 
  
  " x) V' c. w# a  O当前子进程 id: 5380
  
  
• 
  ' V  z- U) x+ I( h" h3 P
  ; ?0 X$ X$ y" b! `& P: B--------------
  
  + |! H% ?$ j0 V, _9 [2 a5 h/ g
• 
  / ~1 v* o- H& s! K* ^( X
  这里是  Process-5
  , F5 j8 p  l' n% V* H! ?
  / \* d, R: Z0 d. ?$ Y  d' r
• 
  # Y4 r' {3 k% S  S/ y, S, m2 d% t
  模块名称: __mp_main__
  
  
• 
  7 W+ o# `/ J! q
  # g7 n- o3 K: ?4 p' V父进程 id: 880
  " t( c7 }: K% D
  
• 
  
  4 v7 r; k3 Q3 [6 e* r$ \/ p当前子进程 id: 3520
  ( [7 `( ~( n; [, l, |) ?& \
  
• 
  
  / p1 o- w* o% U$ F4 ~# x--------------
  " x3 F* @( y' B- Y8 ^% H8 u+ [% D
  
  : D$ p. ?0 ?5 X  S

1. 进程间的数据共享

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

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

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

• 
  
  from multiprocessing import Process
  & X* }; N  B  x* g, Y
  
• 
  
  9 p0 \+ m. F4 w, j$ j/ _
  - r  ^; s' ]3 s& G; ^( h
  
• 
  
  lis = []
  
  & r' ?; m' t2 ], j  ?  A! r" Q
• 
  
  . M- p% D5 b* G' T, [
  & Z4 r, C+ }2 }* [8 b- j5 i
  
• 
  ) e1 ]7 Q& \+ h' J; o1 }9 y
  def foo(i):
  9 ^2 f, E- |+ D7 L. @* g
  ( A( _, Z7 }( s! F
• 
    N0 L! u, x6 m4 s* w
      lis.append(i)
  ; ^! N. N! n9 c3 E) P0 S3 D
  
• 
  6 f5 V. o8 ]) G( Z3 X8 L4 k
      print("This is Process ", i," and lis is ", lis, " and lis.address is  ", id(lis))
  
  
• 
  ( ~# c) z' {% T8 ]0 l+ C
  & q- p# p5 j$ \0 T  O& L7 M
  9 ^1 j0 A' `6 e. }& t+ L
  
• 
  ) {/ W$ A- c( A0 c$ w& G
  if __name__ == '__main__':
  
  * k* ^& y( d7 v' z# P9 v
• 
  
  ( I! t3 H( F$ m& K    for i in range(5):
  6 i. D6 y4 m5 d* a2 X
  " `1 _3 A6 N3 R1 V
• 
  * b- E! `5 Q! G  H
          p = Process(target=foo, args=(i,))
  : j  s% ^& ]7 G4 L, @  [
  7 y; I, P5 d& \7 D" Z& c4 H0 b' Y
• 
  
          p.start()
    o$ W8 u( o+ L1 O) s
  7 y  x9 M+ w. J$ J7 Y* B7 `3 X
• 
  * d! v( w; X  T0 @  K" o
      print("The end of list_1:", lis)
  
  
  

运行结果：

• 
    N, |1 W' U8 C- v7 o
    h6 ^, B7 c: L* _' O" |3 o* `6 zThe end of list_1: []
  8 y8 m6 s8 h$ d
  9 U) I$ X! n/ S9 H( Y
• 
    d9 L$ B: q! F2 \) I& f
  " c$ O, r- ?0 z- UThis is Process  2  and lis is  [2]  and lis.address is   40356744
  
  ! a8 D; y7 i2 z/ N5 V7 o& o2 T
• 
  ( U5 I2 c% V! z. M) y  T7 k( j; w5 t
  1 [" r* J! h0 `- {This is Process  1  and lis is  [1]  and lis.address is   40291208
  
  ' j; e  |& X* g; x
• 
  
  This is Process  0  and lis is  [0]  and lis.address is   40291208
  
  
• 
  $ \$ n6 ~3 j- H0 S. _+ ^  S
  This is Process  3  and lis is  [3]  and lis.address is   40225672
  
  
• 
  
  + C3 z5 r$ l6 [$ e* f! ?2 QThis is Process  4  and lis is  [4]  and lis.address is   40291208
  8 l. j/ l# z: [
  ; Y1 V, X1 T# t& _6 S8 T4 @0 g2 l
  

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

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

1.1 使用Array共享数据

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

• 
  5 S6 z) u' J2 E9 a5 J0 Z# ^7 h1 y
  # |5 \2 M7 u8 P3 }( R% X'c': ctypes.c_char, 'u': ctypes.c_wchar,
  
  
• 
  
  'b': ctypes.c_byte, 'B': ctypes.c_ubyte,
  
  ) w( C: x. F, Z2 R/ I- K- f" G
• 
  
  6 T  V4 y; d9 u  j- G9 R( l4 r'h': ctypes.c_short, 'H': ctypes.c_ushort,
  
  
• 
  
  'i': ctypes.c_int, 'I': ctypes.c_uint,
  1 R# U: ~9 I5 r  O/ P3 _+ J
  
• 
  
  'l': ctypes.c_long, 'L': ctypes.c_ulong,
  
  
• 
  8 @4 ?% L" L- ], _. c0 j
  ! s5 m# W0 {0 A/ M$ f'f': ctypes.c_float, 'd': ctypes.c_double
  
  
  : I3 l/ F' J. D% Q+ A1 z

看下面的例子：

• 
  
  from multiprocessing import Process
  . C5 f& r: P9 y) ^! I0 L
  % `0 E' s. U% ]1 E" P1 d
• 
  
  from multiprocessing import Array
  
  , _  |5 M8 N" n- X# @
• 
  5 W* n' F& ~3 H. W6 l& p5 x
  
  " W) R8 |, V6 z0 E
  ! V9 N; B  `) y& `' `/ ~+ u8 B; V( T
• 
  . a$ i4 A9 @' w
  def func(i,temp):
  ( Y4 P. ?3 x1 z0 U/ k/ g
  , t6 a& N9 A, O# F
• 
  ; j) @6 i# Z. B
  1 b" x# [3 i2 U- b  _1 f    temp[0] += 100
  
  
• 
  
  , {  o& A2 ]. V- n2 [  T  L    print("进程%s " % i, ' 修改数组第一个元素后----->', temp[0])
  + F( _' r& d  E
  
• 
  * D4 t- T5 x5 M9 P& m" K
  # v- O3 n9 e  z  O
  
  
• 
  % W/ B4 ]/ Z; v, A
  . ?  ^' j: }' d$ \if __name__ == '__main__':
  
  
• 
  
      temp = Array('i', [1, 2, 3, 4])
  ! }+ z# [* j2 z+ K
  
• 
  
  & g! ~9 U" o3 q. L    for i in range(10):
  & U7 a$ e" J3 B& i% e$ d. _
  
• 
  # b. q& q9 v* N
          p = Process(target=func, args=(i, temp))
  2 L$ Y! x0 u/ x" k1 r3 P+ m3 r1 q
  
• 
  
          p.start()
  
  & ?: v! g- R; n) A' @& z
  

运行结果：

• 
  
  + {9 l% W# O6 |进程2   修改数组第一个元素后-----> 101
  # Y7 T3 Q9 l+ K0 ]8 ^; S( u
  
• 
  + z: K5 p/ X7 O" w3 `
  进程4   修改数组第一个元素后-----> 201
  
  * A, o! q) O' G  y1 C
• 
  
  ! u8 u$ R, L. f6 O进程5   修改数组第一个元素后-----> 301
  
  
• 
  
    r7 R# E3 W& v( L' y8 G进程3   修改数组第一个元素后-----> 401
  # C# \* Z5 h( l  X+ p
  
• 
  8 B; Z0 t+ E4 N2 v& Y6 o$ B
  2 r6 G" P, x5 j; D, g2 {进程1   修改数组第一个元素后-----> 501
  
  7 m2 Y% M# n8 C- O% T
• 
  3 Q: o* v7 @3 ]/ Z% F
  " J" _5 l0 W8 I' p进程6   修改数组第一个元素后-----> 601
  
  - c& y/ F: ~6 g# D# x0 Y
• 
  
  进程9   修改数组第一个元素后-----> 701
  ! L) C3 ^( y" `4 X6 {: b: R
  8 I+ K/ x' o" J% a
• 
  
  进程8   修改数组第一个元素后-----> 801
  5 M& C$ d! |" G& t1 I% N. b9 N+ c
  : P8 ]% [$ s2 C  M
• 
  
  进程0   修改数组第一个元素后-----> 901
  
  
• 
  
  3 h% F& @* L" Q! u进程7   修改数组第一个元素后-----> 1001
  & n7 K6 B+ t' _
  
  

1.2 使用Manager共享数据

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

• 
  : @1 @: y8 {. d* v: t" t, I
  from multiprocessing import Process
  
  
• 
  * z+ a( U% O+ [' U/ K! m6 v
  from multiprocessing import Manager
  
  
• 
  
  - c. T. N0 z/ P  t. e! `3 v: Q* g
  
  $ T% s8 g  u. [# |: A: Y/ Z, c
• 
  
  & _+ u; y7 G1 R, J2 Z) Ndef func(i, dic):
  
  
• 
  6 v: O* [: o; c5 b3 e
  6 ~* d  [$ Z7 \( H2 {) l9 Y% @- f    dic["num"] = 100+i
  
  
• 
  
      print(dic.items())
  
  / B6 g) `, q' u3 Z& Y6 B. f
• 
  
  
  3 f8 p; K. D- X. U
    v. J1 q# j2 `0 d
• 
  
  if __name__ == '__main__':
  
  
• 
  ) G0 Z) W3 \( ^5 @/ N. Y: c/ O4 o
      dic = Manager().dict()
  7 M$ `0 O9 O2 c
  0 R# y0 h' M( P1 t' B% `
• 
  * c# d7 {& X. _
      for i in range(10):
  / `( C' t( Q9 @+ I: b
    L, @+ A9 D. Q' k; X" C* U
• 
  , }2 Z, ~4 F! G" `9 \
          p = Process(target=func, args=(i, dic))
  6 u3 j- g  g2 e6 o
  7 L& X- b1 C- ~0 m0 |
• 
  % a& h# f. j4 O$ R; b4 [
  ! h, \5 {- ]3 [7 F1 K5 t' G( ^0 R        p.start()
  7 ~2 v! s2 [1 ?* P: r) p
  & u9 ^% |- Y; j) F
• 
  5 c- T+ K, c& L" S8 A7 b4 G
  " r- p: s( E; F, ~; F! X        p.join()
  
  8 E# j! F1 B5 p1 l, f
  

运行结果：

• 
  
  [('num', 100)]
  
  1 V( W) X& Z; y! k2 W% c9 D) A
• 
  ; T( ], p7 I" q8 g3 c& |3 x& P* L
  [('num', 101)]
  " J9 o# X  E. s8 J
  " o7 m2 Y# ]4 R
• 
  
  [('num', 102)]
  
  # C* F6 f; k% m$ X# X2 D! t, l
• 
  
  [('num', 103)]
  
  0 |! O! H. M. i& H4 `
• 
  
  [('num', 104)]
  
  
• 
  
  ! v/ _8 b: w, E* V9 O[('num', 105)]
  
  
• 
  & n0 i3 L8 ]4 ^  X2 E
  [('num', 106)]
  
  
• 
  
  [('num', 107)]
  
  
• 
  3 Z; [# w' Z  B1 \7 E$ a
  " b, t6 |( A& m7 s3 @% S[('num', 108)]
  ) t* ]7 S/ |2 t4 N% s
  3 h6 Z; {2 k+ G
• 
  4 e8 i3 h# `. B9 s) u  |
  & G: z& u  B) e4 Q[('num', 109)]
  
  ' D( w+ W, R3 G
  

1.3 使用queues的Queue类共享数据

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

• 
  , e* ^  u4 w* i7 T% n
  import multiprocessing
  
  ! b/ ]% U: c4 Z
• 
  
  & E8 m7 E$ S) x3 }from multiprocessing import Process
  
  + t+ h* A7 g  M* [0 j$ o% Y
• 
  
  ! M7 z  v4 E* Z3 Yfrom multiprocessing import queues
  
  * Y% c- r+ x7 C* ^
• 
  
  ' i' z+ l5 b% z
  " N  v, x0 a' _* n
  * \, @- ]5 J# r- f! Y, t
• 
  
  def func(i, q):
  7 _' G) r$ ]" d. {; f2 |9 w
  
• 
  5 {  g- \2 L- `
      ret = q.get()
  : Q. v- P1 i" U/ Q$ \1 x: H
  & X- b& Z7 }/ _+ ]: l& V
• 
  8 Z3 z8 d6 E( J6 n: ~# W
      print("进程%s从队列里获取了一个%s，然后又向队列里放入了一个%s" % (i, ret, i))
  + @0 l. Q( o$ t$ D, @9 v7 V
  
• 
  ( g7 X. V9 k: v9 L+ g, X; H' G
      q.put(i)
  / l4 s% T1 u: |, n8 ]6 T: v0 D
  
• 
  # i' S. g/ x/ f4 I$ c* n
  9 {# o/ o% U/ A% W1 ^
  % n: S( x+ P; ~
  
• 
  8 u* \9 C% K; ~. M7 Q! @' h$ x
  if __name__ == "__main__":
  , r0 @4 u; n+ E9 Y: z6 o  Q
  
• 
  & H, @& S% R( W5 M
  9 A% F. S* X/ a/ |( h2 V2 W" D% F    lis = queues.Queue(20, ctx=multiprocessing)
  
  4 \; Z3 v8 o9 X
• 
  
  0 {) c3 G! X! j    lis.put(0)
  
  
• 
  
  4 U+ O" n$ ^1 }    for i in range(10):
  
  & ~( |# }0 f* o/ m1 Q  `
• 
  + G" ]; v' Z: v  H4 m" {4 x! I
          p = Process(target=func, args=(i, lis,))
  % ?+ Q+ d3 Y" q" _% y  B7 K
  
• 
  5 g% }- r$ c/ O
  + T% `; @- n: ?8 M$ F( p        p.start()
  ; Z( o: U6 V  u0 B) P! G: ~
  ' T$ ]; u/ v1 G. c% n
  

运行结果：

• 
  
  " @# ]5 P9 [: M% f% [# d- j' t进程1从队列里获取了一个0，然后又向队列里放入了一个1
    B0 _0 t) Y9 l' h7 M, h
  
• 
  
  进程4从队列里获取了一个1，然后又向队列里放入了一个4
  1 T& g' B. a# p" N$ I2 \
  
• 
  ; u5 }4 e: e! r/ S, l) F0 ^5 C" T5 W
  进程2从队列里获取了一个4，然后又向队列里放入了一个2
  6 T% W& l$ ]' o4 ~
  
• 
  
  ! |: V9 @1 b* C8 D2 G; P7 T' y进程6从队列里获取了一个2，然后又向队列里放入了一个6
  
  
• 
  2 J4 g4 K' }/ E+ l/ z! `, Q. }! n
  5 z" C0 o$ u4 o8 T进程0从队列里获取了一个6，然后又向队列里放入了一个0
  8 X6 t: b1 M, e/ s' }/ f; @7 ~
  " q0 i$ E4 V8 f* Y' j* b
• 
  . C( r5 ~, ~; m2 _
  进程5从队列里获取了一个0，然后又向队列里放入了一个5
  ! q$ {% s9 p6 [& X1 G6 g. C
  ( q4 f9 `5 ]8 h  B+ ]& E
• 
  
  进程9从队列里获取了一个5，然后又向队列里放入了一个9
  
  % }5 G. R4 N8 K8 o/ o( r0 |, O( M' V
• 
  
  进程7从队列里获取了一个9，然后又向队列里放入了一个7
  
  / i; m; u9 ^0 v( o2 @
• 
  
  进程3从队列里获取了一个7，然后又向队列里放入了一个3
  
  
• 
  
  3 |: s7 a# C1 b! m6 l  L进程8从队列里获取了一个3，然后又向队列里放入了一个8
  
  ! X7 u2 W' ^, `# h, S* J
  6 Q5 o" m5 G; g0 p/ c) j

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

2. 进程锁

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

• 
  4 O( ?/ O' ]6 z4 t; ?0 \& z; ~+ Z
  . A6 ?3 M$ }0 n! _% m  hfrom multiprocessing import Process
  ( w0 R/ B4 [# g% [: ]
  / N" [, q3 k5 j  Q$ |/ Z
• 
  4 R# t. Z1 `  M4 O  g/ \
  from multiprocessing import Array
  
  
• 
  4 u9 i3 y" ?6 @. Z, R
  from multiprocessing import RLock, Lock, Event, Condition, Semaphore
  
  
• 
  
  import time
  " h# x. J/ ~. |8 ?0 u$ V! ]. S- s& A
  , K% L5 }; O/ _% u3 C
• 
  . v, n  x" Z- l: x
  6 K8 k, D0 L& w  c
  / M' x: o3 B9 x. Z! H$ v& ]
  
• 
  
  def func(i,lis,lc):
  
  
• 
  
  6 m, @. Z- J1 C- d3 ?    lc.acquire()
  
  
• 
  6 p- C+ Y9 Y7 y0 Q! |& i
      lis[0] = lis[0] - 1
  " _) ^( T; h3 ]/ M
  ) U2 [6 D$ y! c0 c4 n1 ]
• 
  ) w  E( I6 _9 t4 Q4 K4 _
      time.sleep(1)
  * G  g8 }- R+ ]: D
  
• 
  
      print('say hi', lis[0])
  1 h/ t- D- k( D9 u" l* c* c6 n; g
  
• 
  
  0 D) s$ T/ `& v3 E    lc.release()
  
  8 j0 ]9 i6 J, J2 j; S
• 
  & T4 G: Q2 X: ~: o( p& m, p& ?* R1 T
  
  : C! f( Q7 z- t  }1 u# ]
  
• 
  / t3 s3 K! _- w3 m( Y0 |8 b
  if __name__ == "__main__":
  1 ]8 y8 M4 {1 W' V* g" c
  
• 
  0 H" @/ B  W" }  `. J9 N
  ; ~% }1 |7 X6 ^4 c& q8 v    array = Array('i', 1)
  
  " _4 r! x9 |: K+ a) J0 i
• 
  
  " j* K! w" f7 r0 T    array[0] = 10
  
    j) y$ m2 q* A0 w4 m  G
• 
  0 ]8 R) o, u5 o' B- q
      lock = RLock()
  - k8 H% u/ c5 f4 R9 h7 s
  
• 
  
  / F$ _+ U4 c; \) b" O    for i in range(10):
  / Z( [3 x( F4 U5 \8 h
  
• 
  ; l9 o5 f; X3 z0 Y' C# _+ \
  2 `, y, v$ [$ c  l, A5 @: G  ?; ^+ }2 Y        p = Process(target=func, args=(i, array, lock))
  
  
• 
  
          p.start()
  9 j0 G: Y  H7 m! I# s0 P/ r
  
  , q4 G. J7 g; v6 s7 e% ]3 i7 E0 a

运行结果：

• 
  6 {; ~7 e  B% g9 i
  say hi 9
  
  
• 
  
  + Q6 e7 U: s- G' Esay hi 8
  
  $ G$ g. R6 Z  r! k# Y$ V
• 
  
  say hi 7
  
  - W( M3 g9 k: T6 z: P
• 
  
  say hi 6
  
  5 P! d, v3 ?4 T/ l) ]
• 
  
  say hi 5
  7 o& ~) Y# J' }! m
  
• 
  
  3 y- v/ K" h* n- N" Y' c: u( ]% Q5 isay hi 4
  
  
• 
  
  1 w( A& u. Y( ^. _say hi 3
  
  
• 
  
  say hi 2
  8 s; [0 {7 C- r- R3 M5 f! x
  ( ~2 l- a- i8 \# B5 }
• 
  , y  \$ J5 V0 L
  say hi 1
  
  
• 
  
  * M" \" D7 p. z  ksay hi 0
  
  
  

3. 进程池Pool类

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

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

进程池中常用的方法：

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

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

• terminate() 立刻关闭进程池

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

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

  
  4 X& E1 p' W- B1 r9 [

• 
  
  from multiprocessing import Pool
  
  7 [1 C6 b% R/ u! g4 ]! I1 m
• 
  
  9 D. r6 _$ h9 t+ O; T9 o" kimport time
  * n2 H" @% S9 F$ a
  
• 
  4 }8 I6 L2 B+ @) v
  : B3 U, u/ r* x2 D; e4 L& L5 `
  6 c: D/ u  ?& I" k( }
  
• 
  
  def func(args):
  
  $ |  \% _+ \/ _  h) L
• 
  
      time.sleep(1)
  
  
• 
  
    w4 l: k% z5 J- b/ q6 w- A    print("正在执行进程 ", args)
  + E5 m* n$ F* T0 v
  
• 
  " n8 G2 b% n" g1 ~! @. ?- R' R3 S
  / i2 |3 D+ ~  X& {- s
  
  
• 
  : w( f, z7 ]1 u
  if __name__ == '__main__':
  
  ) K0 ?: B$ t' H; R0 l* G7 m/ ?
• 
  0 n( l; \4 l* ~$ o$ q
  2 c8 A% M0 j1 y. a, k
  
  6 f# R( `1 u8 G; m* J3 ~
• 
  
  ) e2 M" |, t( S5 i  Z    p = Pool(5)     # 创建一个包含5个进程的进程池
  8 S7 t% `. ~6 L9 Q2 u
  3 ?0 W( u) e% _& N, r
• 
  $ q$ K; D4 Y7 Y2 L1 t2 ^
  
  - V4 Q3 J  ^, v6 D; B: ?
  
• 
  / M( C- H6 G! [) g. D
      for i in range(30):
  
  
• 
  
          p.apply_async(func=func, args=(i,))
  
  ) j: J0 g0 W: C' S7 F; c
• 
  
  
  
  ) A+ u+ S7 x$ |/ o' k0 m
• 
  
      p.close()           # 等子进程执行完毕后关闭进程池
  ! v) A" q& U  a6 g* T
  6 a/ K% z7 [+ E+ B% m* X( u1 r
• 
  
  6 m9 h) S+ P$ a) B& G: K/ h. `- y    # time.sleep(2)
  ; ]6 Y: w, R: Z
  
• 
  , F4 P3 N) i# o+ k+ ?
      # p.terminate()     # 立刻关闭进程池
  
  , y+ E6 @: u) b! H
• 
  
      p.join()
  , R% h1 v' K  p- w% W
  - g3 F1 N0 F# `' _$ q
  " H7 g8 X% }8 ^0 o+ \" D( l, k2 m

' ]# d# w: ?& @/ @$ t

请继续关注我

' m+ c1 u+ P  L  ?7 {1 U. m