python中文件句柄的关闭问题

qqrilxk

父进程创建子进程，然后父子间使用multiprocessing.Queue()来进行通信。
首先子进程退出，关闭Queue,然后父进程也关闭Queue.

这时，使用命令lsof -c python3|egrep 'pipe|sem' ,会发现有pipe和sem似乎没被关闭，这是怎么回事？并且，每多创建一个子进程然后退出，就会有越来越多的pipe和sem句柄存留。求教怎么彻底关闭这些句柄，谢谢。
测试代码如下：
import os,sys,time,multiprocessing,queue,threading,signal
pdict = {}

def child(name,req):
        while True:
                ret = 'a'
                try:
                        ret = req.get(timeout=5)
                        print("%s get %s" %(name,ret))
                        time.sleep(10)
                        msg = "%s  exit now" %(name)
                        print(msg)
                        time.sleep(1)
                        req.close()
                        del req
                        os._exit(4)
                except Exception as e:
                        print("child err,%s" %str(e))

def start_child(name,req):
        print("to start %s now" %name)
        p = multiprocessing.Process(target=child, args=(name,req) )
        p.start()
        pdict[name] = [req,p]


def main():
        print(" main start now")
        req = ''
        count = 0       
        signal.signal(signal.SIGCHLD,signal.SIG_IGN)
        while True:
                count = 0
                while True:
                        count = count + 1
                        name = "child#%s" %count
                        req = multiprocessing.Queue()
               
                        print("\n")
                        print("start %s child now ......" %name)
                        p1 = threading.Thread( target=start_child,args = (name,req))                                                                                                                       
                        p1.start()

                        req.put([count])                       
                        time.sleep(13)                       
                               
                        rq = pdict[name][0]
                        p = pdict[name][1]
                        rq.close()
                        rq.close()
                        del rq
                        print("clear %s resource\n" %name)
                        time.sleep(20)
                        print(" begin the %s round now #################" %(count+1))                                       

if __name__ == "__main__":
        main()


随着子进程的创建退出，lsof显示如下：
第一个子进程创建后退出：
[root@Steve ~]# lsof -c python3|egrep 'pipe|sem'
python3 5135 root  DEL    REG   0,16          18198145 /dev/shm/sem.rBbhHD
python3 5135 root  DEL    REG   0,16          18198144 /dev/shm/sem.Z4yneZ
python3 5135 root  DEL    REG   0,16          18198143 /dev/shm/sem.DnUuLk
python3 5135 root    5r  FIFO    0,8      0t0 18198146 pipe


第二个子进程创建后退出：
[root@Steve ~]# lsof -c python3|egrep 'pipe|sem'
python3 5135 root  DEL    REG   0,16          18203718 /dev/shm/sem.1pq5ru
python3 5135 root  DEL    REG   0,16          18203717 /dev/shm/sem.B2iNRc
python3 5135 root  DEL    REG   0,16          18203716 /dev/shm/sem.xu6vhV
python3 5135 root  DEL    REG   0,16          18198145 /dev/shm/sem.rBbhHD
python3 5135 root  DEL    REG   0,16          18198144 /dev/shm/sem.Z4yneZ
python3 5135 root  DEL    REG   0,16          18198143 /dev/shm/sem.DnUuLk
python3 5135 root    5r  FIFO    0,8      0t0 18198146 pipe
python3 5135 root    6r  FIFO    0,8      0t0 18203719 pipe


第三个子进程创建后退出：
[root@Steve ~]# lsof -c python3|egrep 'pipe|sem'
python3 5135 root  DEL    REG   0,16          18209232 /dev/shm/sem.xhO5xe
python3 5135 root  DEL    REG   0,16          18209231 /dev/shm/sem.DXxJQj
python3 5135 root  DEL    REG   0,16          18209230 /dev/shm/sem.xHio9o
python3 5135 root  DEL    REG   0,16          18203718 /dev/shm/sem.1pq5ru
python3 5135 root  DEL    REG   0,16          18203717 /dev/shm/sem.B2iNRc
python3 5135 root  DEL    REG   0,16          18203716 /dev/shm/sem.xu6vhV
python3 5135 root  DEL    REG   0,16          18198145 /dev/shm/sem.rBbhHD
python3 5135 root  DEL    REG   0,16          18198144 /dev/shm/sem.Z4yneZ
python3 5135 root  DEL    REG   0,16          18198143 /dev/shm/sem.DnUuLk
python3 5135 root    5r  FIFO    0,8      0t0 18198146 pipe
python3 5135 root    6r  FIFO    0,8      0t0 18203719 pipe
python3 5135 root    7r  FIFO    0,8      0t0 18209233 pipe

qqrilxk

都没人吱一声啊

jeppeter

回复 1# qqrilxk

关键是这一句

1. signal.signal(signal.SIGCHLD,signal.SIG_IGN)

复制代码

你要自己处理child退出的信号处理，如果处理了，就没有你说的问题了。
再提醒一下，你最好用代码标签来处理你的代码，这样人家看起来会舒服很多。

qqrilxk

谢谢楼上回复。
signal.signal(signal.SIGCHLD,signal.SIG_IGN)
这个默认忽略后，我在主进程后面对Queue有close操作啊。
如果注掉此行，然后在主进程后面wait一下，再对Queue进行close，现象是一样的。
还请大侠指点，谢谢。

jeppeter

1. import os,sys,time,multiprocessing,queue,threading,signal
   
2. pdict = {}
   
3. 
   
4. def child(name,req):
   
5.     while True:
   
6.         ret = 'a'
   
7.         try:
   
8.             ret = req.get(timeout=5)
   
9.             print("%s get %s" %(name,ret))
   
10.             time.sleep(10)
    
11.             msg = "%s  exit now" %(name)
    
12.             print(msg)
    
13.             time.sleep(1)
    
14.             req.close()
    
15.             del req
    
16.             os._exit(4)
    
17.         except Exception as e:
    
18.             print("child err,%s" %str(e))
    
19. 
    
20. def start_child(name,req):
    
21.     print("to start %s now" %name)
    
22.     p = multiprocessing.Process(target=child, args=(name,req) )
    
23.     p.start()
    
24.     pdict[name] = [req,p]
    
25. 
    
26. 
    
27. def main():
    
28.     print(" main start now")
    
29.     req = ''
    
30.     count = 0      
    
31.     signal.signal(signal.SIGCHLD,signal.SIG_IGN)
    
32.     while True:
    
33.         count = 0
    
34.         while True:
    
35.             count = count + 1
    
36.             name = "child#%s" %count
    
37.             req = multiprocessing.Queue()
    
38.             print("\n")
    
39.             print("start %s child now ......" %name)
    
40.             p1 = threading.Thread( target=start_child,args = (name,req))                                                                                                                       
    
41.             p1.start()
    
42.             req.put([count])                       
    
43.             time.sleep(13)
    
44.             rq = pdict[name][0]
    
45.             p = pdict[name][1]
    
46.             rq.close()
    
47.             rq.close()
    
48.             del rq
    
49.             print("clear %s resource\n" %name)
    
50.             pdict[name][0] = None
    
51.             pdict[name][1] = None
    
52.             time.sleep(20)
    
53.             print(" begin the %s round now #################" %(count+1))                                       
    
54. 
    
55. if __name__ == "__main__":
    
56.     main()
    

复制代码

回复 4# qqrilxk

这里加了

1.             pdict[name][0] = None
   
2.             pdict[name][1] = None
   

复制代码

你以后要写代码，最好用格式化，要不你的代码看起来费劲。因为python是自动 回收，你原来的数据有数据无法删除。这样你的数据就可以了。

qqrilxk

谢谢楼上指点。
关于下面这两条代码，我以前试过了，我刚刚又试了一下，现象是一样的。还是存在句柄增加的问题。

1. pdict[name][0] = None
   
2. pdict[name][1] = None

复制代码

这个问题我花了很长时间偿试，还请大侠多费心帮帮，万分感谢。

另外关于代码格式，多谢指点，我以前真没太注意就直接贴上来了。

bskay

44行是什么
            rq = pdict[name][0]
            p = pdict[name][1]
            rq.close()
            rq.close()
后面一个是p.close()吧

jeppeter

1. import os,sys,time,multiprocessing,queue,threading,signal
   
2. pdict = {}
   
3. 
   
4. def child(name,req):
   
5.     try:
   
6.         ret = req.get(timeout=5)
   
7.         print("%s get %s (%d)" %(name,ret,os.getpid()))
   
8.         #time.sleep(1)
   
9.         #req.close()
   
10.         #del req
    
11.     except Exception as e:
    
12.         print("child err,%s" %str(e))
    
13.     sys.exit(0)
    
14.     return
    
15. 
    
16. def start_child(name,req):
    
17.     print("to start %s now" %name)
    
18.     p = multiprocessing.Process(target=child, args=(name,req) )
    
19.     p.start()
    
20.     return p
    
21. 
    
22. 
    
23. def main():
    
24.     print(" main start now")
    
25.     req = ''
    
26.     count = 0      
    
27.     #signal.signal(signal.SIGCHLD,signal.SIG_IGN)
    
28.     count = 0
    
29.     while True:
    
30.         count = count + 1
    
31.         name = "child#%s" %count
    
32.         req = multiprocessing.Queue()
    
33.         p = start_child(name,req)
    
34.         req.put([count])
    
35.         req.close()
    
36.         del req
    
37.         req = None
    
38.         print("clear %s resource (%d)\n" %(name,p.pid))
    
39.         #p.join()
    
40.         del p
    
41.         p = None
    
42.         print("begin the %s round now #################" %(count+1))
    
43.     return
    
44. 
    
45. 
    
46. if __name__ == "__main__":
    
47.     main()
    
48. 
    

复制代码

最关键的一句还是注释了

1. #signal.signal(signal.SIGCHLD,signal.SIG_IGN)

复制代码

这样，multiprocessing 就会正确处理进程退出了，原来的处理，让multiprocessing不能正确处理。这一次是对了。

qqrilxk

这样处理似乎还是有点问题。
这样处理结果是：当程序运行到print("begin the %s round now #################" %(count+1))  这一行时，还是有句柄在打开的（在这行后增加time.sleep(10)可看到）。
这里对原程序的最大一个修改是删掉了全局变量pdict = {}对子进程信息的记录。这就使得每次运行到print("begin the %s round now #################" %(count+1))  这一行时，都只有相同数量的句柄在打开（没有句柄增加，可在这一行时应该是没有句柄才对），似乎规避了句柄增加的问题。
可我的问题是，我需要全局变量dict来记录子进程的信息（包括Queue和其它信息），在重启此子进程时释放Queue，因此这样做不太合本意。
从你上面的修改来看，如果不对子进程的Queue进行记录，在子进程后Queue的句柄就关闭了（回收了）。
但是，如果我们对其进行记录，为什么就不能通过close和del 来使得其关闭并回收呢？
到底需要怎样才能使得其得到关闭回收，这是我想知道的。下面是测试代码

1. import os,sys,time,multiprocessing,queue,threading,signal
   
2. pdict = {}
   
3. count = 0
   
4. 
   
5. def sigchld_handler(signum,frame):
   
6.         os.waitpid(-1, os.WNOHANG)
   
7.         name = "child#%s" %count
   
8.         rq = pdict[name][0]
   
9.         p = pdict[name][1]
   
10.         rq.close()
    
11.         rq.close()
    
12.         del rq
    
13. 
    
14. 
    
15. def child(name,req):
    
16.         while True:
    
17.                 ret = 'a'
    
18.                 try:
    
19.                         ret = req.get(timeout=5)
    
20.                         print("%s get %s" %(name,ret))
    
21.                         time.sleep(4)
    
22.                         msg = "%s  exit now" %(name)
    
23.                         print(msg)
    
24.                         time.sleep(1)
    
25.                         req.close()
    
26.                         del req
    
27.                         os._exit(4)
    
28.                 except Exception as e:
    
29.                         print("child err,%s" %str(e))
    
30. 
    
31. def start_child(name,req):
    
32.         print("to start %s now" %name)
    
33.         p = multiprocessing.Process(target=child, args=(name,req) )
    
34.         p.start()
    
35.         pdict[name] = [req,p]
    
36. 
    
37. 
    
38. def main():
    
39.         print(" main start now")
    
40.         req = ''
    
41.                
    
42.         signal.signal(signal.SIGCHLD,signal.SIG_IGN)
    
43.         #signal( SIGCHLD, sigchld_handler );
    
44.         while True:
    
45.                 count = 0
    
46.                 while True:
    
47.                         count = count + 1
    
48.                         name = "child#%s" %count
    
49.                         req = multiprocessing.Queue()
    
50.                
    
51.                         print("\n")
    
52.                         print("start %s child now ......" %name)
    
53.                         p1 = threading.Thread( target=start_child,args = (name,req))                                                                                                                       
    
54.                         p1.start()
    
55. 
    
56.                         req.put([count])                       
    
57.                         time.sleep(6)                       
    
58.                
    
59.                         pdict[name][0].close()
    
60.                         del pdict[name][1]
    
61.                         del pdict[name][0]
    
62.                         print("clear %s resource\n" %name)
    
63.                         #pdict[name][0] = None
    
64.                         #pdict[name][1] = None
    
65.                         pdict[name] = None
    
66.                         time.sleep(10)
    
67.                         print(" begin the %s round now #################" %(count+1))                                       
    
68. 
    
69. if __name__ == "__main__":
    
70.         main()
    

复制代码

jeppeter

1. import os,sys,time,multiprocessing,queue,threading,signal
   
2. pdict = {}
   
3. 
   
4. def child(name,req):
   
5.     try:
   
6.         ret = req.get(timeout=5)
   
7.         print("%s get %s (%d)" %(name,ret,os.getpid()))
   
8.         #time.sleep(1)
   
9.         #req.close()
   
10.         #del req
    
11.     except Exception as e:
    
12.         print("child err,%s" %str(e))
    
13.     sys.exit(0)
    
14.     return
    
15. 
    
16. def start_child(name,req):
    
17.     print("to start %s now" %name)
    
18.     p = multiprocessing.Process(target=child, args=(name,req) )
    
19.     p.start()
    
20.     return p
    
21. 
    
22. 
    
23. def main():
    
24.     print(" main start now")
    
25.     req = ''
    
26.     count = 0      
    
27.     #signal.signal(signal.SIGCHLD,signal.SIG_IGN)
    
28.     count = 0
    
29.     while True:
    
30.         count = count + 1
    
31.         name = "child#%s" %count
    
32.         req = multiprocessing.Queue()
    
33.         p = start_child(name,req)
    
34.         pdict[name] = [req,p]
    
35.         req.put([count])
    
36.         pdict.pop(name,None)
    
37.         req.close()
    
38.         del req
    
39.         req = None
    
40.         print("clear %s resource (%d)\n" %(name,p.pid))
    
41.         #p.join()
    
42.         del p
    
43.         p = None
    
44.         print("begin the %s round now #################" %(count+1))
    
45.     return
    
46. 
    
47. 
    
48. if __name__ == "__main__":
    
49.     main()
    
50. 
    

复制代码

回复 9# qqrilxk

这里就实现了你的功能，至于你说的，不是立刻删除，这个是PYTHON内部实现的机制，是一种LAZY-MODE的方式，不是一出现垃圾就回收，而是等一会儿，垃圾比较多了，再一起回收的问题，只要运行超过1000个以上的实例，没有出现大幅的增加FILE就可以了。