关于Pipe()的一个疑问

介左来了

主进程中建了一个管子，每个子进程中也有使用管子的返回值，按理说，每个进程中的管子的两个口都是分配了独立的内存空间的，为什么进程间还能通过管子通讯呢？每个管子的两个口，通过id的输出 显示的很清楚了，不一样啊。

1. from multiprocessing import Process,Pipe
   
2. 
   
3. def demo1(pipe):
   
4.     left,right=pipe
   
5.     print('demo1,left.fileno is %d,right.fileno is %d'%(left.fileno(),right.fileno()))
   
6.     print('demo1,id(left) is %d,id(right) is %d'%(id(left),id(right)))
   
7.     right.close()  
   
8.     while True:
   
9.         try:
   
10.             s = left.recv()
    
11.             print(s)
    
12.         except:
    
13.             left.close()
    
14.             print('pipe close')
    
15.             break
    
16. 
    
17. def demo2(pipe):
    
18.     left,right=pipe
    
19.     print('demo2,left.fileno is %d,right.fileno is %d'%(left.fileno(),right.fileno()))
    
20.     print('demo2,id(left) is %d,id(right) is %d'%(id(left),id(right)))
    
21.     left.close()  
    
22.     for i in range(5):
    
23.         try:
    
24.             right.send(i)
    
25.         except:
    
26.             print('pipe close')
    
27.             break
    
28.     right.close()
    
29. 
    
30. 
    
31. if __name__ == '__main__':
    
32.     pipe=Pipe()
    
33.     left, right = pipe
    
34.     print('__main__,left.fileno is %d,right.fileno is %d'%(left.fileno(),right.fileno()))
    
35.     print('__main__,id(left) is %d,id(right) is %d'%(id(left),id(right)))
    
36.     p1=Process(target=demo1,args=(pipe,))
    
37.     p2=Process(target=demo2,args=(pipe,))
    
38.     p1.start()
    
39.     p2.start()
    
40.     left.close()
    
41.     right.close()

复制代码

Stubborn

从头到尾，你的pipe=Pipe()  都是用的一个，你还不如这样写

1. if __name__ == '__main__':
   
2.     pipe=Pipe()
   
3.     p1=Process(target=demo1,args=(pipe,))
   
4.     p2=Process(target=demo2,args=(pipe,))
   
5.     p1.start()
   
6.     p2.start()

复制代码

两个管道

1.     left, right = Pipe(), Pipe()
   
2.     print('__main__,id(left) is %d,id(right) is %d'%(id(left),id(right)))

复制代码

进程不是很熟，不过进程之前通讯，也可以同队队列来处理，同理这个Pip管道，应该也是类似队列，你这里是创建了一个‘队列’，多个标识符引用而已

介左来了

Stubborn 发表于 2020-1-14 20:55
从头到尾，你的pipe=Pipe()  都是用的一个，你还不如这样写

pipe = Pipe() 在主进程中是这样，但是创建了子进程之后，子进程会复制父进程和数据结构，还会创建独立的内存空间，所以你在进程看到的对象其实新的了，我觉得奇怪的地方就在这，为何不是一个管道，但是还可以保持通讯？

left, right = Pipe(), Pipe()
你这样写的话，不对吧，改变了这个赋值的初衷了，left，right的类型也变了

Stubborn

介左来了 发表于 2020-1-14 21:25
pipe = Pipe() 在主进程中是这样，但是创建了子进程之后，子进程会复制父进程和数据结构，还会创建独立的 ...

直接用队列把  简单  进程没有仔细学，帮不到你。

介左来了

Stubborn 发表于 2020-1-14 21:35
直接用队列把  简单  进程没有仔细学，帮不到你。

用队列 是比较清晰，我再考虑一下这个问题。