在Python中mutilprocessing Processing父子進程共享檔案物件注意事項

巴扎黑
發布: 2017-04-15 09:04:48
原創
1691 人瀏覽過

multiprocessing python多進程模組, 於是, Processing也是多進程的寵兒. 但今天討論的問題, 似乎也能引起我們一番重視

直接上代碼:

from multiprocessing import Process, Lock
err_file = 'error1.log'  
err_fd = open(err_file, 'w')

def put(fd):
     print "PUT"
     fd.write("hello, func put write\n")
     print "END"

if __name__=='__main__':
    p_list=[]
    for i in range(1):
        p_list.append(Process(target=put, args=(err_fd,)))    
    for p in p_list:
        p.start()
    for p in p_list:
        p.join()
登入後複製
登入後複製

上面的程式碼意圖很清晰: 透過multiprocessing.Process派生一個進程, 去執行put函數, put函數的作用也是很清楚, 輸出PUT和END, 並且將"hello, func put write" 寫到文件error1.log中.

那麼按理說, 輸出應該如同上面說的那樣, PUT和END,然後error1.log將有那句話"hello, func put write", 然而, 世事總有那麼點難料的, 代碼執行結果是:

[root@iZ23pynfq19Z ~]# py27 2.py ; cat error1.log 
PUT
END
[root@iZ23pynfq19Z ~]#
登入後複製
登入後複製

what! ?為什麼error1.log沒東西!?

讓我們稍微調整下程式碼, 再見證神奇的事情:

from multiprocessing import Process, Lock
err_file = 'error1.log'  
err_fd = open(err_file, 'w')

def put(fd):
     print "PUT"
     fd.write("hello, func put write\n")
     fd.write("o" * 4075) # 神奇的一行
     print "END"

if __name__=='__main__':
    p_list=[]
    for i in range(1):
        p_list.append(Process(target=put, args=(err_fd,)))    for p in p_list:
        p.start()
    for p in p_list:
        p.join()
登入後複製
登入後複製

輸出結果:

[root@iZ23pynfq19Z ~]# py27 2.py ; cat error1.log 
PUT
END
hello, func put write
o....(有4075个)
[root@iZ23pynfq19Z ~]#
登入後複製
登入後複製

有沒有覺得一種懵逼的感覺!?

如今, 心中湧現兩個問題:

  1. #為什麼第一個程式無法寫入那句話, 但是第二個卻可以?

  2. 那個4075是什麼鬼?
    在解釋這些問題之前, 我們需要清楚標準IO庫所具有的特點: 全緩衝, 行緩衝, 不緩衝

具體可以看​​之前博文:https://my.oschina.net/u/2291...

因為現在是寫入檔案, 所以系統IO將採取全緩衝的方式, 也就是說, 會將緩衝區填滿才刷入系統寫隊列.

所以上面的問題就一下子全解決了, 正因為那些迷一般的' o',填滿了整個緩衝區, 所以系統將我們的內容刷進去寫隊列,所以4075怎麼來, 就是用4096-sizeof("hello, func put writen")+1, 為什麼要+1, 因為緩衝區滿還不行, 要大於才能觸發寫動作.

所以我們現在已經能夠得出答案, 如果我們想要在multiprcessing.Process中, 用上面類似的方式去寫文件時,有三種方法去實作:

  • 寫滿緩衝區

  • #手動呼叫flush()

  • 將文件物件設定成不緩衝
    第一第二種在上面已經闡述, 那我們簡單講下第三種:

#
取自Python官网Document:
open(name[, mode[, buffering]])
  ...
  The optional buffering argument specifies the file’s desired buffer size: 0 means unbuffered, 
  1 means line buffered, any other positive value means use a buffer of (approximately) that 
  size (in bytes). A negative buffering means to use the system default, which is usually line 
  buffered for tty devices and fully buffered for other files. If omitted, the system default is 
  used. [2]
登入後複製
登入後複製

上圖說明就是, 允許我們在open的時候, 設定buffering為0, 那麼就是unbuffered模式, 那麼在每次寫, 就是直接寫入寫隊列,而不是寫到緩衝區.(性能最低的方式)

------ ------------------------------------------我是切割線---- ------------------------------------------

談完現象與處理的方法, 我們應該來點深入的;

相信我們曾經試過, 在沒有顯示關閉文件對像或者顯示調用flush時, 文件依舊能夠正常寫入,那麼又是怎麼一回事呢?

其實,在我們正常關閉程序時, 進程在退出將會為我們做一些"手尾", 例如關閉打開的文件描述符, 清理臨時文件,清理內存等等.正是因為系統的這種"好習慣", 所以我們的資料在文件描述符關閉時,就能刷入寫隊列,文件內容也不會丟失.

那麼基於這種認識,我們再回首剛才的問題, 在子程序調用put的時候, 理論上在程序退出時, 並沒顯示關閉文件描述符, 所以數據在緩衝區就丟失了.

讓我們在順藤摸瓜,看Process的實作

multiprocessing/Processing.py
    def start(self):
        '''
        Start child process
        '''
        assert self._popen is None, 'cannot start a process twice'
        assert self._parent_pid == os.getpid(), \
               'can only start a process object created by current process'
        assert not _current_process._daemonic, \
               'daemonic processes are not allowed to have children'
        _cleanup()
        if self._Popen is not None:
            Popen = self._Popen
        else:
            from .forking import Popen
        self._popen = Popen(self)
        _current_process._children.add(self)
登入後複製
登入後複製

再看下Popn是怎麼做?

multiprocessing/forking.py
    class Popen(object):

        def __init__(self, process_obj):
            sys.stdout.flush()
            sys.stderr.flush()
            self.returncode = None

            self.pid = os.fork()
            if self.pid == 0:
                if 'random' in sys.modules:
                    import random
                    random.seed()
                code = process_obj._bootstrap()
                sys.stdout.flush()
                sys.stderr.flush()
                os._exit(code)
登入後複製
登入後複製

關鍵地方就是最後的os._exit(code), 為什麼說最關鍵? 因為這部分的退出, 將決定進程會處理什麼"手尾",

os._exit是什麼鬼?  其實就是標準庫的_eixt, 於是我們又能簡單學習這東西了

https://my.oschina .net/u/2291...

在上面的連結, 我們能夠比較清楚看到_exit() 和exit() 是比較不同的兩個東西, _exit()  簡單暴力, 直接丟棄使用者狀態的內容,進入核心, 而exit()則比較耐心地為我們清理

那麼我們是否能夠假設: 如果Popen的退出不是os._exit() 會是怎樣的效果呢?

很幸運的是, sys.exit() 就是我們先要的exit(), 事不宜遲, 趕緊試下!

multiprocessing/forking.py
    class Popen(object):

        def __init__(self, process_obj):
            sys.stdout.flush()
            sys.stderr.flush()
            self.returncode = None

            self.pid = os.fork()
            if self.pid == 0:
                if 'random' in sys.modules:
                    import random
                    random.seed()
                code = process_obj._bootstrap()
                sys.stdout.flush()
                sys.stderr.flush()
                #os._exit(code)
                sys.exit(code)
登入後複製
登入後複製

測試程式碼, 返回最原始那個沒有'o'填充的版本

[root@iZ23pynfq19Z ~]# python 2.py ; cat error1.log 
PUT
END
hello, func put write
登入後複製
登入後複製

我們可以看到, 確實是可以寫進去, 這樣就證明上面的說法是站得住腳步的

不過最好還是不要亂改源碼哦, 畢竟這些都是老前輩多年優化的結果,可能這是他們故意這些寫,為了避免某些問題.還是規範好自己的行為,盡量減少這些看起來不怎麼規範的實現思路吧
歡迎各位大神指點交流,轉載請註明: https://segmentfault.com/a/11...


multiprocessing python多進程模組, 於是, Processing也是多進程的寵兒. 但今天討論的問題, 似乎也能引起我們一番重視

直接上代碼:

from multiprocessing import Process, Lock
err_file = 'error1.log'  
err_fd = open(err_file, 'w')

def put(fd):
     print "PUT"
     fd.write("hello, func put write\n")
     print "END"

if __name__=='__main__':
    p_list=[]
    for i in range(1):
        p_list.append(Process(target=put, args=(err_fd,)))    
    for p in p_list:
        p.start()
    for p in p_list:
        p.join()
登入後複製
登入後複製

上面的代碼意圖很清晰: 通過multiprocessing.Process派生一個進程, 去執行put函數, put函數的作用也是很清楚, 輸出PUT和END, 並且將"hello, func put write" 寫到檔案error1.log中.

那么按理说, 输出应该如同上面说的那样, PUT和END,然后error1.log将有那句话"hello, func put write", 然而, 世事总有那么点难料的, 代码执行结果是:

[root@iZ23pynfq19Z ~]# py27 2.py ; cat error1.log 
PUT
END
[root@iZ23pynfq19Z ~]#
登入後複製
登入後複製

what!? 为什么error1.log没东西 !?

让我们稍微调整下代码, 再见证神奇的事情:

from multiprocessing import Process, Lock
err_file = 'error1.log'  
err_fd = open(err_file, 'w')

def put(fd):
     print "PUT"
     fd.write("hello, func put write\n")
     fd.write("o" * 4075) # 神奇的一行
     print "END"

if __name__=='__main__':
    p_list=[]
    for i in range(1):
        p_list.append(Process(target=put, args=(err_fd,)))    for p in p_list:
        p.start()
    for p in p_list:
        p.join()
登入後複製
登入後複製

输出结果:

[root@iZ23pynfq19Z ~]# py27 2.py ; cat error1.log 
PUT
END
hello, func put write
o....(有4075个)
[root@iZ23pynfq19Z ~]#
登入後複製
登入後複製

有没有觉得一种懵逼的感觉!?

如今, 心中涌现两个问题:

  1. 为什么第一个程序无法写入那句话 , 但是第二个却可以?

  2. 那个4075是什么鬼?
    在解释这些问题之前, 我们需要清楚标准IO库所具有的特点: 全缓冲, 行缓冲, 不缓冲

具体可以看之前博文:https://my.oschina.net/u/2291...

因为现在是写入文件, 所以系统IO将采用全缓冲的方式, 也就是说, 会将缓冲区填满才刷入系统写队列.

所以上面的问题就一下子全解决了, 正因为那些 迷一般的 'o',填满了整个缓冲区, 所以系统将我们的内容刷进去写队列,所以4075怎么来, 就是用4096-sizeof("hello, func put writen")+1, 为什么要+1, 因为缓冲区满还不行, 要大于才能触发写动作.

所以我们现在已经能够得出答案, 如果我们想要在multiprcessing.Process中, 用上面类似的方式去写文件时,有三种方法去实现:

  • 写满缓冲区

  • 手动调用flush()

  • 将文件对象设置成不缓冲
    第一第二种在上面已经阐述, 那我们简单讲下第三种:

取自Python官网Document:
open(name[, mode[, buffering]])
  ...
  The optional buffering argument specifies the file’s desired buffer size: 0 means unbuffered, 
  1 means line buffered, any other positive value means use a buffer of (approximately) that 
  size (in bytes). A negative buffering means to use the system default, which is usually line 
  buffered for tty devices and fully buffered for other files. If omitted, the system default is 
  used. [2]
登入後複製
登入後複製

上图说明就是, 允许我们在open的时候, 设置buffering为0, 那么就是unbuffered模式, 那么在每次写, 就是直接写入写队列,而不是写到缓冲区.(性能最低的方式)

------------------------------------------------我是切割线----------------------------------------------

谈论完现象和处理的方法, 我们应该来点深入的;

相信我们曾经试过, 在没有显示关闭文件对象或者显示调用flush时, 文件依旧能够正常写入,那么又是怎么一回事呢?

其实,在我们正常关闭程序时, 进程在退出将会为我们做一些"手尾", 例如关闭打开的文件描述符, 清理临时文件,清理内存等等.正是因为系统的这种"好习惯", 所以我们的数据在文件描述符关闭时,就能刷入写队列,文件内容也不会丢失.

那么基于这种认识,我们再回首刚才的问题, 在子进程调用put的时候, 理论上在程序退出时, 并没显示关闭文件描述符, 所以数据在缓冲区就丢失了.

让我们在顺藤摸瓜,看Process的实现

multiprocessing/Processing.py
    def start(self):
        '''
        Start child process
        '''
        assert self._popen is None, 'cannot start a process twice'
        assert self._parent_pid == os.getpid(), \
               'can only start a process object created by current process'
        assert not _current_process._daemonic, \
               'daemonic processes are not allowed to have children'
        _cleanup()
        if self._Popen is not None:
            Popen = self._Popen
        else:
            from .forking import Popen
        self._popen = Popen(self)
        _current_process._children.add(self)
登入後複製
登入後複製

再看下Popn是怎么做?

multiprocessing/forking.py
    class Popen(object):

        def __init__(self, process_obj):
            sys.stdout.flush()
            sys.stderr.flush()
            self.returncode = None

            self.pid = os.fork()
            if self.pid == 0:
                if 'random' in sys.modules:
                    import random
                    random.seed()
                code = process_obj._bootstrap()
                sys.stdout.flush()
                sys.stderr.flush()
                os._exit(code)
登入後複製
登入後複製

关键地方就是最后的 os._exit(code), 为什么说最关键? 因为这部分的退出, 将决定进程会处理什么"手尾",

os._exit是什么鬼?  其实就是标准库的_eixt, 于是我们又能简单学习这东西了

https://my.oschina.net/u/2291...

在上面的链接, 我们能够比较清楚看到 _exit() 和exit() 是比较不同的两个东西, _exit()  简单暴力, 直接丢弃用户态的内容,进入内核, 而exit()则比较耐心地为我们清理

那么我们是否能够假设: 如果Popen的退出不是os._exit() 会是怎样的效果呢?

很幸运的是, sys.exit() 就是我们先要的exit(), 事不宜迟, 赶紧试下!

multiprocessing/forking.py
    class Popen(object):

        def __init__(self, process_obj):
            sys.stdout.flush()
            sys.stderr.flush()
            self.returncode = None

            self.pid = os.fork()
            if self.pid == 0:
                if 'random' in sys.modules:
                    import random
                    random.seed()
                code = process_obj._bootstrap()
                sys.stdout.flush()
                sys.stderr.flush()
                #os._exit(code)
                sys.exit(code)
登入後複製
登入後複製

测试代码, 返回最原始那个没有'o'填充的版本

[root@iZ23pynfq19Z ~]# python 2.py ; cat error1.log 
PUT
END
hello, func put write
登入後複製
登入後複製

我们可以看到, 确实是可以写进去, 这样就证明上面的说法是站得住脚步的

不过最好还是不要乱改源码哦, 毕竟这些都是老前辈多年优化的结果,可能这是他们故意这些写,为了避免某些问题.还是规范好自己的行为,尽量减少这些看起来不怎么规范的实现思路吧


以上是在Python中mutilprocessing Processing父子進程共享檔案物件注意事項的詳細內容。更多資訊請關注PHP中文網其他相關文章!

來源:php.cn
本網站聲明
本文內容由網友自願投稿,版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容,請聯絡admin@php.cn
熱門教學
更多>
最新下載
更多>
網站特效
網站源碼
網站素材
前端模板
關於我們 免責聲明 Sitemap
PHP中文網:公益線上PHP培訓,幫助PHP學習者快速成長!