<p>multiprocessing python多进程模块, 于是, Processing也是多进程的宠儿. 但今天讨论的问题, 似乎也能引起我们一番重视</p>    <p>直接上代码:</p>    <pre>  <code class="language-python">frommultiprocessingimportProcess, Lock  err_file = 'error1.log'    err_fd = open(err_file, 'w')     defput(fd):      print "PUT"      fd.write("hello, func put writen")      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()  </code></pre>    <p>上面的代码意图很清晰: 通过multiprocessing.Process派生一个进程, 去执行put函数, put函数的作用也是很清楚, 输出PUT和END, 并且将”hello, func put write” 写到文件error1.log中.</p>    <p>那么按理说, 输出应该如同上面说的那样, PUT和END,然后error1.log将有那句话”hello, func put write”, 然而, 世事总有那么点难料的, 代码执行结果是:</p>    <pre>  <code class="language-python">[root@iZ23pynfq19Z ~]# py27 2.py ; cat error1.log  PUT  END  [root@iZ23pynfq19Z ~]#  </code></pre>    <p>what！？ 为什么error1.log没东西 !?</p>    <p>让我们稍微调整下代码, 再见证神奇的事情:</p>    <pre>  <code class="language-python">frommultiprocessingimportProcess, Lock  err_file = 'error1.log'    err_fd = open(err_file, 'w')     defput(fd):      print "PUT"      fd.write("hello, func put writen")      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()  </code></pre>    <p>输出结果:</p>    <pre>  <code class="language-python">[root@iZ23pynfq19Z ~]# py27 2.py ; cat error1.log  PUT  END  hello, funcputwrite  o....(有4075个)  [root@iZ23pynfq19Z ~]#  </code></pre>    <p>有没有觉得一种懵逼的感觉!?</p>    <p>如今, 心中涌现两个问题:</p>    <ol>     <li>为什么第一个程序无法写入那句话 , 但是第二个却可以?</li>     <li>那个4075是什么鬼?</li>    </ol>    <p>在解释这些问题之前, 我们需要清楚标准IO库所具有的特点: 全缓冲, 行缓冲, 不缓冲</p>    <p>因为现在是写入文件, 所以系统IO将采用全缓冲的方式, 也就是说, 会将缓冲区填满才刷入系统写队列.</p>    <p>所以上面的问题就一下子全解决了, 正因为那些 迷一般的 ‘o’,填满了整个缓冲区, 所以系统将我们的内容刷进去写队列,所以4075怎么来, 就是用4096-sizeof(“hello, func put writen”)+1, 为什么要+1, 因为缓冲区满还不行, 要大于才能触发写动作.</p>    <p>所以我们现在已经能够得出答案, 如果我们想要在multiprcessing.Process中, 用上面类似的方式去写文件时,有三种方法去实现:</p>    <ol>     <li>写满缓冲区</li>     <li>手动调用flush()</li>     <li>将文件对象设置成不缓冲</li>    </ol>    <p>第一第二种在上面已经阐述, 那我们简单讲下第三种:</p>    <pre>  <code class="language-python">取自Python官网Document:  open(name[, mode[, buffering]])    ...    Theoptionalbufferingargumentspecifiesthefile’s desiredbuffersize: 0 meansunbuffered,     1 meanslinebuffered, anyotherpositivevaluemeansuse a bufferof (approximately) that    size (in bytes). A negativebufferingmeansto use thesystemdefault, whichis usuallyline    bufferedfor ttydevicesand fullybufferedfor otherfiles. If omitted, thesystemdefault is     used. [2]  </code></pre>    <p>上图说明就是, 允许我们在open的时候, 设置buffering为0, 那么就是unbuffered模式, 那么在每次写, 就是直接写入写队列,而不是写到缓冲区.(性能最低的方式)</p>    <p>————————————————我是切割线———————————————-</p>    <p>谈论完现象和处理的方法, 我们应该来点深入的;</p>    <p>相信我们曾经试过, 在没有显示关闭文件对象或者显示调用flush时, 文件依旧能够正常写入,那么又是怎么一回事呢?</p>    <p>其实,在我们正常关闭程序时, 进程在退出将会为我们做一些”手尾”, 例如关闭打开的文件描述符, 清理临时文件,清理内存等等.正是因为系统的这种”好习惯”, 所以我们的数据在文件描述符关闭时,就能刷入写队列,文件内容也不会丢失.</p>    <p>那么基于这种认识,我们再回首刚才的问题, 在子进程调用put的时候, 理论上在程序退出时, 并没显示关闭文件描述符, 所以数据在缓冲区就丢失了.</p>    <p>让我们在顺藤摸瓜,看Process的实现</p>    <pre>  <code class="language-python">multiprocessing/Processing.py      defstart(self):          '''          Start child process          '''          assert self._popenis 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._Popenis not None:              Popen = self._Popen          else:              from .forkingimportPopen          self._popen = Popen(self)          _current_process._children.add(self)  </code></pre>    <p>再看下Popn是怎么做?</p>    <pre>  <code class="language-python">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:                      importrandom                      random.seed()                  code = process_obj._bootstrap()                  sys.stdout.flush()                  sys.stderr.flush()                  os._exit(code)  </code></pre>    <p>关键地方就是最后的 os._exit(code), 为什么说最关键? 因为这部分的退出, 将决定进程会处理什么”手尾”,</p>    <p>os._exit是什么鬼?  其实就是标准库的_eixt, 于是我们又能简单学习这东西了</p>    <p><a href="/misc/goto?guid=4959737489408077231" rel="nofollow,noindex">https://my.oschina.net/u/2291453/blog/813259</a></p>    <p>在上面的链接, 我们能够比较清楚看到 _exit() 和exit() 是比较不同的两个东西, _exit()  简单暴力, 直接丢弃用户态的内容,进入内核, 而exit()则比较耐心地为我们清理</p>    <p>那么我们是否能够假设: 如果Popen的退出不是os._exit() 会是怎样的效果呢?</p>    <p>很幸运的是, sys.exit() 就是我们先要的exit(), 事不宜迟, 赶紧试下!</p>    <pre>  <code class="language-python">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:                      importrandom                      random.seed()                  code = process_obj._bootstrap()                  sys.stdout.flush()                  sys.stderr.flush()                  #os._exit(code)                  sys.exit(code)  </code></pre>    <p>测试代码, 返回最原始那个没有’o’填充的版本</p>    <pre>  <code class="language-python">[root@iZ23pynfq19Z ~]# python 2.py ; cat error1.log  PUT  END  hello, funcputwrite  </code></pre>    <p>我们可以看到, 确实是可以写进去, 这样就证明上面的说法是站得住脚步的</p>    <p>不过最好还是不要乱改源码哦, 毕竟这些都是老前辈多年优化的结果,可能这是他们故意这些写,为了避免某些问题.还是规范好自己的行为,尽量减少这些看起来不怎么规范的实现思路吧</p>    <p> </p>    <p>来自：http://python.jobbole.com/87360/</p>    <p> </p>