数学建模社区-数学中国

标题: 爬虫（七十）多进程multiprocess（六十一） [打印本页]

---

作者: 杨利霞    时间: 2020-5-31 10:35
标题: 爬虫（七十）多进程multiprocess（六十一）

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

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

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

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

• 
  # m. J, I7 D& C, h. E
  9 I3 m2 a# f" t; A# n7 w- Vimport os
  7 [3 R# W2 H% {# J
  
• 
  
  $ E- f2 G! N  W# T  Q6 ^import multiprocessing
  
  
• 
  
  
  
  
• 
  9 w- ]8 ^& s5 s: n
  ) e+ L. L9 _$ l$ ^# z: ]def foo(i):
  2 Y+ S: z0 E/ }7 f3 X
  
• 
  
  ; T4 F! ?. q9 u1 b  k& C    # 同样的参数传递方法
  
  
• 
  1 J2 ^& S1 W8 A) E
  $ l5 C5 y, F/ q1 S' }& @/ x9 ?    print("这里是 ", multiprocessing.current_process().name)
  
  7 X/ b; T2 _$ K; O) e9 Z
• 
  
  9 N3 ]: Y6 ]* q! o* q8 d    print('模块名称:', __name__)
  
  
• 
  
  8 l' s8 ]3 W$ x; {8 v9 K) \    print('父进程 id:', os.getppid())  # 获取父进程id
  
  ) R" Y- d% z6 ?0 k- X
• 
  
  $ ]7 ^. d+ \- _. }) g    print('当前子进程 id:', os.getpid())  # 获取自己的进程id
  ' k; P2 q7 T$ x
  7 l, q! c' n0 N; t) |
• 
  + B- W. ^) h+ R! E7 g/ U( l
      print('------------------------')
  
  
• 
  
  
  ' g- {/ m' u/ y0 h9 c
  
• 
  
  / j1 m4 I( P8 }) c9 vif __name__ == '__main__':
  
  0 d" p; ~, F9 c
• 
  3 N: K9 Z! f9 L$ s  }$ w+ X; h
  " n; y" `; ^. i5 k
  
  - f+ i4 o/ D# Q' @. v7 l/ k
• 
  ; L. {" |+ r7 R  @
      for i in range(5):
  6 s+ }+ f9 {: A
  , B0 a5 s; G. z; _+ ~
• 
  
          p = multiprocessing.Process(target=foo, args=(i,))
  
  & G  _5 P4 n# V) _6 H
• 
  
          p.start()
  
  2 f' r9 }& B' `  k4 r* |
  

运行结果：

• 
  
  这里是  Process-2
  
  
• 
  
  8 d, X7 u9 s+ O, a1 u7 ~/ U1 f) C模块名称: __mp_main__
  - v- w' F% p5 f. `
  8 N' ~3 a& ~4 ]3 a! ~& v5 \/ Q1 V
• 
  # f; o' y  I% X" b1 V5 Q
  $ l4 y7 K- I. Y! i4 K! J, |父进程 id: 880
  : ]4 A1 G8 ^6 D! W) D( c7 M
  
• 
  2 }5 e7 O* ~$ s6 F, ]
  当前子进程 id: 5260
  9 Y0 V4 }$ p8 ~% F1 h  X
  
• 
  
  --------------
  
  
• 
  
  4 s% K7 F4 H) e5 u9 g$ ?& `这里是  Process-3
  ' e0 [8 ?( r. v/ l" j3 ?/ f
  6 X' Z5 `7 H; y3 c! @5 l
• 
  
  模块名称: __mp_main__
  
  2 m9 I- \# w/ o8 U
• 
  * X' g: @5 u% ]1 {- B+ T, f; F
  父进程 id: 880
  6 Z: s: L% F; |9 k# l
  
• 
  
  " q  U0 w1 W( k* y* O5 `8 Q: E% }当前子进程 id: 4912
  
  
• 
  
  --------------
  ' b3 J2 K6 y6 `8 m* L& e1 j
  , W( c3 Y9 O* X9 H
• 
  
  ; a" P! V- q0 W$ y' j$ e- `这里是  Process-4
  
  ; H2 O$ l$ X/ G9 f, D+ O  R
• 
  
  模块名称: __mp_main__
  
  
• 
  3 u) j5 V$ W& _
  % b$ a7 W# T# S0 u) |1 l父进程 id: 880
  
  
• 
  
  当前子进程 id: 5176
  6 |4 ]* h0 Q& j4 G
  
• 
  . n6 h( e( W  E. g( @% ]
  " w' x# h9 ]! w: v7 N' R( ?# D--------------
  
  ( T0 [0 W* P/ G2 C; z( x4 G- c0 G3 Q
• 
  
  6 N! N3 P9 q0 s这里是  Process-1
  & d7 D' v3 Y+ u$ r4 f. w& t
  
• 
  
  1 r! R1 r6 l; c4 T5 H模块名称: __mp_main__
  
  6 f: s) X5 E& N+ c9 N. d0 J
• 
  
  父进程 id: 880
  
  
• 
  2 V" d, p% r5 j) X
  4 U) i, F% V$ \* i! m当前子进程 id: 5380
  ( n% v* S# \. A2 V( m3 K+ F
  , M0 R2 b# b' P0 Z4 p
• 
  
  - X  |7 l  H6 e; }( N3 O8 n--------------
  ( S+ U2 p( n/ _+ [% x; M
  
• 
  4 q6 m& s/ _: t  t' I+ z8 l
  1 N( u0 J9 r" M; q这里是  Process-5
  
  8 M! f! E3 R* S' U! L( K
• 
  ) C+ F! Z9 ~" q2 ?: w
  % \  h1 D! n! \! @0 h+ P/ `. d模块名称: __mp_main__
  # B; R$ b# r0 [' X0 M1 q
  ) e( k" t9 X4 U  _+ `5 ^
• 
  5 {  D' W  D. r6 E. u
  父进程 id: 880
  
  
• 
  
  当前子进程 id: 3520
  . N* b, ^' v/ b% S" @. c
  % ]( a1 n0 {+ X
• 
  * f5 e% K6 d# I
  --------------
  & n) L. s- x4 \+ ^4 H; a
  0 S& t; N3 \7 h/ H7 \( c( B: A
  

1. 进程间的数据共享

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

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

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

• 
  6 \! i5 B7 J; y
  from multiprocessing import Process
  
  4 W; G! v. h  t1 H$ v
• 
  # D3 l0 {4 u9 R5 J
  ( a+ S6 z; }% W) k
  ( V$ ]5 B& G* {8 \4 N' T' @0 t4 u
  * I. s- A6 T/ r% v6 i, M! N9 v& S* b
• 
  " _2 b$ y8 b4 [) @( v2 \; o
  9 d( ^6 g' K1 i" A% Xlis = []
  / Z& j5 R: s& N
  ! L3 P/ M0 @; }4 T, g
• 
  ; J- n; g6 m5 F) w$ _( ^
  2 @: t3 ~) O1 k' [8 R; n' W# `
  + f0 |' L$ t7 O. H4 z1 X
  0 r& B4 \; C6 z: J6 W* ~4 x5 z
• 
  
  0 }0 l; E/ p4 @3 ^% _3 h1 ndef foo(i):
  ; f5 a- g& k7 V& y1 X  x7 I
  
• 
  ) e5 W: B8 H1 Y% C" ~0 \% y: D
      lis.append(i)
  ' H  w* o0 b% H. v" ^4 e
  : Z8 e: W7 Z; J4 v
• 
  $ S: h% L4 @6 k7 `( @
      print("This is Process ", i," and lis is ", lis, " and lis.address is  ", id(lis))
  
  
• 
  
  
  
  
• 
  ' E& |- j* I' |/ P
  if __name__ == '__main__':
  % k/ D* p/ z+ P  S$ \5 a
  
• 
  % c* b" H, F8 ^) {4 \0 Q9 c9 _
      for i in range(5):
  
  1 R5 U; N2 y3 G" g2 S
• 
  
          p = Process(target=foo, args=(i,))
  
  
• 
  ' m+ M3 n* _0 y( }
  ) o0 m4 u2 k, d3 F1 |$ }3 J% a: U        p.start()
  
  " L$ _* Q+ e* Q2 W, A
• 
  
      print("The end of list_1:", lis)
  ; p0 \( F( \: g' ^" s& i
  
  5 z4 y, G7 @" Q8 E4 c, z

运行结果：

• 
  1 B& w" a0 l+ [2 W+ d+ D
  The end of list_1: []
  
  : o; I  Y' n" G" u# A
• 
  ( _' O/ k7 q1 R/ G. @" r
  This 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
  
  
• 
  * ~4 g" l' {7 M% v; N
  This is Process  0  and lis is  [0]  and lis.address is   40291208
  
  / C. }: f$ i; ^) C6 R6 H
• 
  
  This is Process  3  and lis is  [3]  and lis.address is   40225672
  
  
• 
    ~3 b7 J' \- C/ k2 m% k. V) y
  $ ]3 t$ d& T. bThis is Process  4  and lis is  [4]  and lis.address is   40291208
  
  % L0 s! f+ N. {6 x$ X7 K3 \/ q# n& v
  ( _$ ?8 K7 a$ ?: O

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

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

1.1 使用Array共享数据

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

• 
  
  'c': ctypes.c_char, 'u': ctypes.c_wchar,
  
  & W1 f" L& x  b% K
• 
  * ]) D; N0 r4 R, P! z. F5 j
  'b': ctypes.c_byte, 'B': ctypes.c_ubyte,
  0 @8 L& }" p5 `/ m$ E0 W3 b2 k( ?
  8 t  G+ U  \* o
• 
  3 w1 h6 r$ g  F  S; V( y5 @5 d- ]! w
  . `' f9 s- r1 k$ Q/ S' f'h': ctypes.c_short, 'H': ctypes.c_ushort,
  ! Y& G. ~$ b/ f6 c) F0 M
  ! ^) }; q4 j& N
• 
  
  'i': ctypes.c_int, 'I': ctypes.c_uint,
  
  
• 
  
  'l': ctypes.c_long, 'L': ctypes.c_ulong,
  6 B/ G# X: g. N7 v
  
• 
  ' N# M# \* |0 P4 ]$ Z  J0 Y! s% J3 g+ d
  'f': ctypes.c_float, 'd': ctypes.c_double
  1 v- h- V9 A0 N6 n' Z( N
  
  

看下面的例子：

• 
  
  0 w" D, P  n& q/ d9 Y2 yfrom multiprocessing import Process
  3 S( _, u) T- C+ |) e8 j# r  e  P/ }
    |2 b. n" d8 W+ k6 ~8 a
• 
  3 h5 c( l( h, T
  from multiprocessing import Array
  
  
• 
  4 r5 G8 D8 t( X9 f. k2 i
  
  ! v( T; G7 ?, o% m( L
  - V9 e7 B# e" r: O& n
• 
  4 @7 |- B6 I( \
  0 b+ {8 ~" U9 Cdef func(i,temp):
  
  
• 
  6 P; H" K; X9 m
  7 e) o+ M# t" d% T  o, z    temp[0] += 100
  
  , h* d. @$ I% {" h! E- F& P8 r9 w
• 
  7 x& h7 B' u0 U: e  D
      print("进程%s " % i, ' 修改数组第一个元素后----->', temp[0])
  4 ~4 |1 I, p) c5 ?6 ~9 [
  ; j9 M+ R# f" z! M
• 
  
  
  
  
• 
  ' L: a) F- }/ ]1 U1 u2 Q
  if __name__ == '__main__':
  % O% \7 N, a0 N4 R. N3 V
    d. O' Z2 q* W: S! P
• 
  ( j5 \5 L6 L1 v+ H4 `
      temp = Array('i', [1, 2, 3, 4])
  
  8 j+ a0 l* _' @  q) _
• 
  " A" h/ |9 D# R" S5 u2 k# w7 c
      for i in range(10):
  ' Y2 i$ x0 t1 u5 ]
  
• 
  * R/ A7 h2 y) x& }' P3 ^" c; i
          p = Process(target=func, args=(i, temp))
  
  . K8 J2 R% O0 e0 W  f0 F
• 
  7 I( t" G0 D& w% V( I; e
  2 _! T, K0 E; `3 l        p.start()
  0 N6 P& H- Y4 N' s+ Z
  9 Q+ r, L0 w6 M4 V
  

运行结果：

• 
  5 U: l0 z4 d! E6 q$ `( }* |
  进程2   修改数组第一个元素后-----> 101
  
  ' }) Y2 D7 y5 C2 i4 T  H
• 
  ) m. D3 q. G5 |8 T/ }6 N' r4 @4 l
  进程4   修改数组第一个元素后-----> 201
  - \2 |, G- c3 v
  
• 
  
  进程5   修改数组第一个元素后-----> 301
  
  " f) H9 p. O' r2 ~- ^8 O: ?$ J
• 
  
  进程3   修改数组第一个元素后-----> 401
  - q& ~2 v" r0 u
  
• 
  
  进程1   修改数组第一个元素后-----> 501
  , c* B5 ~- U% e9 c
  
• 
  
  进程6   修改数组第一个元素后-----> 601
  2 W+ |+ Z2 ^4 K' m* o5 E
  ' t2 |8 g7 x$ m' E
• 
  
  进程9   修改数组第一个元素后-----> 701
  ' L) \1 W; e" \5 e* w, ]' M
  5 P3 u& I3 h; g# H& [
• 
  6 D) \6 S5 A/ }( S" T6 A
  6 S* p7 a- z7 n! R进程8   修改数组第一个元素后-----> 801
  
  " X5 m) n" [1 k# R6 F# ^' g
• 
  / H6 i1 J# Y. b; w
  ! l, w1 j4 A$ b* c# U( b进程0   修改数组第一个元素后-----> 901
  2 w( e4 p; W" c4 c$ @; r* M: s
    V: [1 c' O( X
• 
  
  进程7   修改数组第一个元素后-----> 1001
  
  
  

1.2 使用Manager共享数据

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

• 
  
  2 K$ i7 E3 G* o8 cfrom multiprocessing import Process
  
  
• 
  
  + c. g# ~! c  V: c3 K. T) [: `) ^& afrom multiprocessing import Manager
  # g  [. F1 n1 q/ o" q! T. w
  
• 
  
  
  , I! n" Z$ T9 g9 `0 e
  
• 
  
  # a9 g$ n/ [" f3 ^) Fdef func(i, dic):
  
  
• 
  . j9 ^$ v" c- B. x' }. Q
      dic["num"] = 100+i
  
  7 X: ^# ^; I/ U8 Y
• 
  
    r, J, }+ N1 g0 L+ ]5 @6 ?    print(dic.items())
  5 ^3 R$ X# `, [; W* Q  Q
  ) }% j4 j1 [/ b
• 
  
  
  . L0 T4 P: G% C- N
  
• 
    v2 p: K2 ^8 G9 \  U7 o& h7 f
  * d' h, d3 r( i1 d& M, P& N* e( wif __name__ == '__main__':
  
  1 @# o$ N0 E3 @2 e6 {# b
• 
  
  ' u/ k$ g8 v7 a$ o, P3 ], k    dic = Manager().dict()
  
  
• 
  
  : u, l3 W: g2 s: I    for i in range(10):
  0 W2 K/ x* x; j" [+ F+ g+ r  T
  
• 
    a" W: i# {2 E( Q2 d6 D4 _+ M8 {
          p = Process(target=func, args=(i, dic))
  6 h7 J0 L( H, ?+ `5 s. t4 A
  
• 
  ; n, S/ _" i  g, n
          p.start()
  
  
• 
  
          p.join()
  , n  ]2 ]7 y! N; K! V- Z
  0 O* m0 Z  X, A! C% w3 J
  & D* f1 C$ x& q4 s

运行结果：

• 
  
  / c8 |/ k7 S/ P/ D' a- Y: |1 [& ?[('num', 100)]
  7 M3 y/ I% O! J* o, u0 s+ _
  
• 
  
  , D* z6 v  ^! R1 N' v; q[('num', 101)]
  
  
• 
  ) d8 F+ A  H0 P3 A
  1 M8 G) L7 f% V2 u[('num', 102)]
  : x( d+ e# U5 R
  
• 
  
  0 B7 M2 C3 {* N, |& `[('num', 103)]
  
  
• 
  
    M- |% E5 J" W+ S7 N& f[('num', 104)]
  
  / D! k, N, C( T9 F& k0 m4 {
• 
  
  2 r1 f) y! B- Q/ N[('num', 105)]
  
  ! p# a! x. N# q9 I, J" C
• 
  ' Q' G( ^6 I3 O, Z  n- s2 c
  9 ?! A- L; \  t, y[('num', 106)]
  
  
• 
  
  5 p. ]" F& O2 E9 g7 r[('num', 107)]
  " @* {0 Z( T* c* P/ v: X# [) F
  
• 
  9 m2 k5 e, C1 v* F, b$ ?% L. t: g" o
  + U( c' r! }: D) ?' K[('num', 108)]
  5 N9 j% A$ h# @/ F3 t1 i
  
• 
  
  [('num', 109)]
  
  " _' l9 N/ Z: P& i9 ?: J$ A3 h
  

1.3 使用queues的Queue类共享数据

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

• 
  6 h! h6 O+ Y3 I% I* v
  % G+ d2 j* F9 @" R  Eimport multiprocessing
  5 Y1 t; @0 ^+ @- e9 D" u! U
  
• 
  
  from multiprocessing import Process
  
  9 z, \/ E/ F% d
• 
  + {+ Z( m1 D# b+ |( e1 H/ @
  " c7 J- _* V8 }6 D0 {/ wfrom multiprocessing import queues
  
  
• 
  
  
  
  ) }" I5 |9 o0 t" G
• 
  - B0 T- z0 A- W5 o# x& e. y" \
  def func(i, q):
  
  . E% Q8 d  P$ M, y
• 
  
  9 M% o8 D! `5 o: S% V# Y3 J( b  J$ x    ret = q.get()
  7 S+ b& R: _; d( \
  
• 
  
  2 d4 s/ {8 R* z% _' F7 N    print("进程%s从队列里获取了一个%s，然后又向队列里放入了一个%s" % (i, ret, i))
  : u3 k% G( ?9 |* h( {
  
• 
  " j9 R1 |1 @% K9 |% k/ |8 E
  ' Y1 L3 s; E0 D/ j& k    q.put(i)
  
  / I9 x6 @2 V: x( ?0 U- [, {
• 
  
  
  
  / b4 F# M- ]1 \. k1 r/ c
• 
    u0 h, w% a& ^- V: T
  if __name__ == "__main__":
  ; e/ {* Q6 t+ i' X1 X! r
  $ D( i  `4 T9 T4 u) k9 n
• 
  # ]2 u5 r' [# V
  * k( o. u: M+ w- A    lis = queues.Queue(20, ctx=multiprocessing)
  & g9 L; v1 @$ ^5 J' ]
  
• 
  " s. Z+ F7 g/ _6 j& `/ M0 t
  ; O. g. C8 Y! Z8 C' y" T    lis.put(0)
  
  0 O# V4 y  b2 P. C
• 
  
  , z/ O+ W" t/ F$ G9 k, X# @$ b. h7 r7 K    for i in range(10):
  - }+ @  H- B, J0 T9 e
  
• 
  - D3 o% A# E1 B) A& U+ @
  % `$ v2 e% o: R        p = Process(target=func, args=(i, lis,))
    T1 U! g% D; p! x4 X  W% K. f# Z
  ' |) c2 n, ?; e1 A0 V+ x6 [
• 
    U3 \: @0 H7 k; k# E) V/ t
          p.start()
  
  $ F# l0 F# x  D; L
  

运行结果：

• 
  
  进程1从队列里获取了一个0，然后又向队列里放入了一个1
  
  
• 
  # n) S4 [  E% x8 p" ]: n
  进程4从队列里获取了一个1，然后又向队列里放入了一个4
  
  5 E9 S8 J3 l: u
• 
  
  进程2从队列里获取了一个4，然后又向队列里放入了一个2
  $ ^: s. K4 W! a; g2 v5 u2 d
  / T$ @/ v7 s- ]# A0 P$ h
• 
  8 l; s) A3 p1 p. c$ T" o
  进程6从队列里获取了一个2，然后又向队列里放入了一个6
  
  1 e8 [' y+ z' F) S/ W. _; g" ^
• 
  ' ^1 D, z+ Z3 G5 A, D8 Y( Y
  : X9 g) h3 h9 w1 |$ }0 ^4 @. ~进程0从队列里获取了一个6，然后又向队列里放入了一个0
  + U0 H, Z# V+ B- }
  0 c5 P' M( y1 n! T" k/ X1 @
• 
  , p& _7 c4 \8 k; W- [( e% Q, r8 e9 D
  ; U1 F' c' g! N/ c8 l" o" R进程5从队列里获取了一个0，然后又向队列里放入了一个5
  
  ! X2 J4 j) g' G$ ]6 w% C
• 
  3 N) x: c7 t! `9 F3 q
  0 f; |$ t3 c' h6 q# J/ X# Y进程9从队列里获取了一个5，然后又向队列里放入了一个9
  + ]& M# r" d. r, l0 }  F" J% g+ @
  % n4 y$ ~5 c7 R9 Q& O9 F; z
• 
  
  进程7从队列里获取了一个9，然后又向队列里放入了一个7
  
  - H9 Z& `, z- `% K4 }) m' n
• 
  
  6 _* }9 h8 P- z$ P6 W进程3从队列里获取了一个7，然后又向队列里放入了一个3
  
  1 L9 V! X% j4 \
• 
  
  进程8从队列里获取了一个3，然后又向队列里放入了一个8
  ( I# t8 O/ v2 y
  
  ' D1 T6 g  V# X& n+ `/ K

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

2. 进程锁

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

• 
  
  1 H, F, T9 I' x8 a% Lfrom multiprocessing import Process
  " J& V/ g6 l' x8 m8 ?4 ~8 x% F
  
• 
  
  from multiprocessing import Array
  
  % f: k) \+ b+ @
• 
  $ I2 j$ [' Q1 h2 F
  from multiprocessing import RLock, Lock, Event, Condition, Semaphore
  # ^2 h/ D# p# g; E: T! b
  ; c# z( i% ~% [9 W
• 
  
  * a& m. y0 j- ~- {import time
  
  
• 
  1 E) I  u5 P, N" T) h" _: Q4 K" S
  ( [# X1 ~2 J: @; P3 N4 l# o; i
  
  
• 
  ( Q4 {4 U( }2 {( @0 t3 x
  7 P/ F' w( k: \- idef func(i,lis,lc):
  ) O. K2 K# ~& B: A
  6 _) Q' F1 L  W9 \; ]+ l7 b# M) S
• 
  ( }# k$ K; u$ G4 O
      lc.acquire()
  
  
• 
  + V. x7 _. E4 z
  6 Z- A9 A. l9 ]& p6 `6 t  w4 d    lis[0] = lis[0] - 1
  
  1 t# C2 F$ x6 a
• 
  ( D" W' x& J6 p5 B" w1 I) D0 n; |
      time.sleep(1)
  ) s, `' N: I9 {/ i
  ! e/ C1 r% }" h" q
• 
  
      print('say hi', lis[0])
  
  ' N" s0 J6 q3 ]& g6 S# ^6 Z
• 
  , s# Z9 q/ k# ~& B/ q6 j
      lc.release()
  / \, `( L7 W$ r- B1 r# D
  
• 
  ' D4 A, A$ V4 K# O- w) f
  / Y' n1 b; R2 i. x  _
  % s5 h" B4 t6 F3 S
  
• 
  ! F; z7 h2 g/ H1 M4 t
  if __name__ == "__main__":
  
  
• 
  9 d: b& s2 d  W' O8 ^! C$ B
      array = Array('i', 1)
  5 n# B% Q$ o7 v2 y% f2 r
  
• 
  2 P: [. X, D% P" A; Y, j' V, q
  0 G! L" o4 j' I! [7 Q: B    array[0] = 10
  : h0 M; |' I. a; P
  7 s4 T: o1 q, E" g& z
• 
  
      lock = RLock()
  5 V. N* o) m  D6 u6 o# T; t( P
  9 F' H1 \; O) b
• 
  3 u& h  w/ I( S) l8 ^% B/ P
      for i in range(10):
  8 {2 M0 W3 ~3 S! _4 u7 P4 I
  
• 
  
  # o8 `: J% @$ E& T1 C* L' m        p = Process(target=func, args=(i, array, lock))
  
  ( J5 M) k+ O3 [3 E
• 
  
  , E+ U- P; W; J" d& P# w        p.start()
  : t/ n2 s. H, p
  $ x- S! W% o! @
  : O( n* \! _8 o0 V- }" d9 f$ F; E

运行结果：

• 
  
  say hi 9
  
  
• 
  
  say hi 8
  ! ^# B7 |( S' ^8 j, v
  
• 
  
  say hi 7
  
  2 a5 j6 p: c1 U% `# V/ a$ V
• 
  
  8 G8 C$ j$ }5 p# Esay hi 6
  
  ; a( L) F5 ]( v3 e8 i0 P3 j
• 
  ' R3 Q, v) v* F; T1 `) P1 E
  , K( ?# P: L* q% Q# }+ Osay hi 5
  
  
• 
  
  say hi 4
  
    t" t8 g! |7 S, k+ _2 j) V
• 
  
  say hi 3
  1 b2 e0 e( r2 a4 x" M$ r+ j) ?/ S- X
  . f9 j6 a1 W& |6 s0 b
• 
  2 c5 S- r9 v0 c3 G% D1 B4 ~1 _
  8 ~3 E- p, X- p: {  {, `say hi 2
  ( W% g3 A) m6 ~  [1 W
  * ^5 U" U0 H4 D1 ~( N3 |- B
• 
  
  5 u& r& V7 G' Qsay hi 1
  
  
• 
    x0 \. o' {% F) |) B# ?& @
  4 S& r" w- v' \8 `say hi 0
  9 m" L' q" N; Z8 z, y3 X
  / h  J% w: l' f
  1 j* t6 i- X2 Y& v+ z

3. 进程池Pool类

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

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

进程池中常用的方法：

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

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

• terminate() 立刻关闭进程池

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

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

  
  

• 
  $ H! }" p( b- C
  - i7 y, b5 N8 z) `from multiprocessing import Pool
  6 u& O3 X2 N1 s3 B( V  B2 t2 `$ M
  * Y, A3 M4 f4 O' T. C
• 
  ) Y5 ?4 e2 [# O) S! ?$ ^
  1 S# D5 g  J8 h* W( {import time
  * \0 }4 z4 k0 D: z: q+ B6 m
  
• 
  
  1 I# l& C9 I9 W1 `; M# d( @4 K! f
  ; S. |% y6 ?" ^8 x/ H
  ; M8 o/ G9 o  \; q
• 
  
  5 L1 Q, t& N% ?8 l! o0 m# N$ t# K6 ~def func(args):
  7 A/ `6 T6 X" n0 i7 S0 E7 E% c2 }
  
• 
  2 Q" c7 {# X: V3 e/ d, K
  , w" o9 F. z' W( q& v* N! y    time.sleep(1)
  
  
• 
  
      print("正在执行进程 ", args)
  
  0 a+ a4 {0 b0 o
• 
  
  
  . r2 s* p" e1 }! s
  ' f' @# Y( y! j1 X: h# y, J
• 
  
  if __name__ == '__main__':
  
  . R1 _. T6 f- o" K/ ^
• 
  
  
  % [1 n6 W( O/ q, l. f# P
  / L5 a4 v5 I$ E9 f3 g- a
• 
  % i# {, G4 K$ h, a1 b' t1 W
      p = Pool(5)     # 创建一个包含5个进程的进程池
  
  
• 
  
  5 |* U5 O# c9 q
  
  
• 
  / P( Y6 K% f: [7 f0 N( A  F
      for i in range(30):
  
  
• 
  
  * F! s+ o. f9 W6 N8 p, v5 g" D3 E        p.apply_async(func=func, args=(i,))
  
  
• 
  ! K/ A$ Z: `" X1 Z' ]# Y- g
  
  / D: b' x# {( g
  3 n! J2 N" I0 r) k6 s
• 
  
  1 ^& Z9 F& {$ M$ `    p.close()           # 等子进程执行完毕后关闭进程池
  
  # E4 L* F$ |( @) p' D" p# Q
• 
  * Y7 s) S6 M9 z# m# z
      # time.sleep(2)
  
  
• 
  + ?! @1 f3 |/ w7 X" E" L
      # p.terminate()     # 立刻关闭进程池
  * |% P4 w9 N7 X" G) l! Q% S$ b% G. a! G
  
• 
  
      p.join()
  
  
  

% z! W. B/ L3 C  f- Y( q$ x

请继续关注我

# o# K* u: G+ q- L! @& {( ^' ~
+ C# h2 _5 \3 L; O. H7 v

---

欢迎光临 数学建模社区-数学中国 (http://www.madio.net/)

Powered by Discuz! X2.5