进程通信和线程通信

进程通信和线程通信

进程间通信：

　　进程是拥有独立空间的，如果开多个进程对某个数据进行处理，由于进程是独立空间，那么两个进程如何通信拥有共同

空间呢？我们可以在父进程里启动一个服务器进程开辟一个公共空间。开启之后在子进程处理数据，父进程也会出现相应的

效果。Manager 是专门用来做共享的！

 1 from multiprocessing import Process, Manager
 2 mgr = Manager()
 3 d = mgr.dict()
 4 def func(d):
 5     d['a'] = 'a'
 6     print(d)
 7 p = Process(target=func, args=(d,))
 8 p.start()
 9 p.join()
10 print(d)
11 # 运行结果：
12 {'a': 'a'}
13 {'a': 'a'}

　　使用Manager之后会失效资源共享，那么出现资源竞争怎么办？(参照线程资源竞争)我们可以使用队列，它默认使用了

锁的功能！使用会非常方便。

 1 from multiprocessing import Process, Queue
 2 q = Queue()
 3 q.put(1)
 4 
 5 
 6 def func(q):
 7     print(q.get())
 8     q.put(2)
 9 
10 
11 p = Process(target=func, args=(q,))
12 p.start()
13 p.join()
14 print(q.get())
15 # 返回结果：（表明队列是共有资源，可以共享）
16 1
17 2

　　如果直接用  import queue  发现资源并没有共享！

 

线程间通信：

　　线程间是共享空间的，每个线程对数据的修改都会起作用。如果两个线程同时修改，那么如果线程一还没有修改完，线程

二就开始修改，这样就会出问题，这个时候就需要线程锁来解决，类似于数据库里的原子操作(最小的操作单元，必须执行完才

能执行其他的)。

 1 from threading import Thread
 2 a = 0
 3 n = 10000000
 4 def incr(n):
 5     global a
 6     for i in range(n):
 7         a += 1
 8 def dncr(n):
 9     global a
10     for i in range(n):
11         a -= 1
12 t1 = Thread(target=incr, args=(n,))
13 t2 = Thread(target=dncr, args=(n,))
14 t1.start()
15 t2.start()
16 t1.join()
17 t2.join()
18 print(a)
19 # 运行多次的结果：
20 -288397    -122765    -1761997

　　可以看出上面的代码出现了资源竞争的情况导致错误执行，我们使用锁来控制资源共享：

 1 from threading import Thread, Lock
 2 
 3 a = 0
 4 n = 10000000
 5 lock = Lock()  # 创建一把锁
 6 
 7 def incr(n):
 8     global a
 9     for i in range(n):
10         lock.acquire()  # 获取一把锁
11         a += 1
12         lock.release()  # 释放锁
13 
14 
15 def dncr(n):
16     global a
17     for i in range(n):
18         lock.acquire()  # 获取一把锁
19         a -= 1
20         lock.release()  # 释放锁
21 
22 
23 t1 = Thread(target=incr, args=(n,))
24 t2 = Thread(target=dncr, args=(n,))
25 t1.start()
26 t2.start()
27 t1.join()
28 t2.join()
29 print(a)

　　创建锁也可以使用with lock:  部分代码如下：运行结果都为0：

1 def incr(n):
2     global a
3     for i in range(n):
4         with lock:
5             a += 1

 

消费者模式和生产者模式：

　　生产者只关心队列是否已经满了，没有就生产，往队列里添加

　　消费者只关心队列是否为空，为空就阻塞

 1 import threading
 2 import random
 3 import queue
 4 
 5 
 6 class Producer(threading.Thread):
 7 
 8     def __init__(self, queue):
 9         super().__init__()
10         self.queue = queue
11 
12     def run(self):
13         for i in range(10):
14             r = random.randint(0, 9)
15             if self.queue.qsize() < 3:
16                 self.queue.put(r)
17                 print('往队列里添加一个数据{}'.format(r))
18 
19 
20 class Consumer(threading.Thread):
21 
22     def __init__(self, queue):
23         super().__init__()
24         self.queue = queue
25 
26     def run(self):
27         for i in range(10):
28             r = random.randint(0, 9)
29             if self.queue.empty():
30                 data = self.queue.get()
31                 print('从队列里get一个数据{}'.format(data))
32 
33 
34 if __name__ == '__main__':
35     q = queue.Queue()
36     p1 = Producer(q)
37     c1 = Consumer(q)
38     p1.start()
39     c1.start()
40     p1.join()
41     c1.join()
42     q.join()

　　这里代码会阻塞，因为我们无法知道两个线程谁先执行，是没有规律的，线程p1几乎是瞬间将循环执行完，所以线程p1

只put了3个数据进去。线程c1在get数据的时候也只能取3个了，然后队列为空，会进去阻塞状态！可以对代码进行改进:

 1 import threading
 2 import random
 3 import queue
 4 import time
 5 
 6 
 7 class Producer(threading.Thread):
 8 
 9     def __init__(self, queue):
10         super().__init__()
11         self.queue = queue
12 
13     def run(self):
14         while True:
15             r = random.randint(0, 9)
16             if not self.queue.full():
17                 self.queue.put(r)
18                 print('往队列里添加一个数据{}'.format(r))
19                 time.sleep(1)
20             else:
21                 print('队列满了')
22 
23 
24 class Consumer(threading.Thread):
25 
26     def __init__(self, queue):
27         super().__init__()
28         self.queue = queue
29 
30     def run(self):
31         while True:
32             data = self.queue.get()
33             print('从队列里get一个数据{}'.format(data))
34             time.sleep(1)
35 
36 
37 if __name__ == '__main__':
38     q = queue.Queue(5)
39     p1 = Producer(q)
40     c1 = Consumer(q)
41     p1.start()
42     c1.start()
43     p1.join()
44     c1.join()
45     q.join()
46 
47 # 代码运行结果：
48 往队列里添加一个数据4
49 从队列里get一个数据4
50 往队列里添加一个数据9
51 从队列里get一个数据9
52 ^CTraceback (most recent call last):
53   File "/home/pyvip/tz_spider/通信/xianchengtongxin.py", line 73, in <module>
54     p1.join()
55   File "/usr/lib/python3.5/threading.py", line 1054, in join
56     self._wait_for_tstate_lock()
57   File "/usr/lib/python3.5/threading.py", line 1070, in _wait_for_tstate_lock
58     elif lock.acquire(block, timeout):
59 KeyboardInterrupt
60 往队列里添加一个数据3
61 从队列里get一个数据3
62 往队列里添加一个数据7
63 从队列里get一个数据7
64 往队列里添加一个数据9
65 从队列里get一个数据9
66 往队列里添加一个数据9
67 从队列里get一个数据9
68 往队列里添加一个数据4
69 从队列里get一个数据4
70 
71 Process finished with exit code -1

　　上面的代码是会一直运行的，这里是手动停止的结果！

 

转载于:https://www.cnblogs.com/dan-baishucaizi/p/8656585.html