进程通信和线程通信

Posted 巴蜀秀才

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了进程通信和线程通信相关的知识,希望对你有一定的参考价值。

进程通信和线程通信

进程间通信:

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

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

效果。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

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

 

以上是关于进程通信和线程通信的主要内容,如果未能解决你的问题,请参考以下文章

进程通信和线程通信

进程通信和线程通信

Java进程间通信和线程间通信?

VC++ 进程间的通信

进程之间的通信

进程/线程同步的方式和机制,进程间通信