Python 如何在读取时不写入文件，反之亦然

我有一个

python

程序（比如

reader.py

），它使用文件

setting.py

来读取：

while( True ):
  ...
  execfile( settings.py )
  ...

但是还有其他

python

程序（比如

writer.py

）使用此文件写入：

...
try:
  settings = open('settings.py', 'w')
  settings.truncate()
  settings.write( 'some text')
except IOError:
  print('Cannot write to file')
finally:
  settings.close()
...

注1:

reader.py

和

writer.py

彼此不“了解”

注2:

reader.py

循环读取

settings.py

，但

writer.py

在用户需要时写入文件（不一定是在他/她单击“写入”后立即写入，这只是意味着在写入时没有任何规则）

问题：为了避免任何矛盾，两个项目合作的最佳方式是什么？我知道这可能取决于平台。我正在使用Linux。发行版有：Ubuntu、Scientific Linux

EDIT1：如果我选择使用

FiFo

，我会遇到以下问题：一旦写入程序写入

设置

文件，它可能永远不会再写入，但无论如何，在这种情况下，读卡器都应该可以访问

设置

。换句话说，在这种情况下，读取器应该能够从文件中读取数据，而不是等待编写器。否则，读者必须等待作者。 如果写入程序不写入（直到写入），则通常使用

FiFo

不允许读取器从文件中读取。如何处理这个问题？

您可能对使用命名管道进行进程间通信感兴趣。在Linux中可用，它是为客户机（writer.py）、服务器（reader.py）和任务设计的一种特殊类型的文件。写入管道后，客户端将等待服务器接收到数据。这允许您在某种程度上同步这两个进程

---

我找到了以下似乎有效的解决方案。我使用

flock

创建锁

阅读器

：

import errno                                                                                    
import fcntl
from time import *

path = "testLock.py"

f = open(path, "r")

while True: 
  try:
    fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
    break   
  except IOError as e:
    if e.errno != errno.EAGAIN:
    raise 
  else:   
    sleep(1)
    print 'Waiting...'

#reader's action      
execfile(path)  
#drop lock          
fcntl.flock(f, fcntl.LOCK_UN)

import errno                                                                                    
import fcntl
from time import *

path = "testLock.py"

f = open(path, "w")

while True: 
  try:
    fcntl.flock(f, fcntl.LOCK_SH | fcntl.LOCK_NB)
    break   
  except IOError as e:
    if e.errno != errno.EAGAIN:
    raise 
  else:   
    sleep(1)
    print 'Waiting...'

#writer's action      
for i in (1,10,2):
  f.write('print "%d" % i')
  sleep(1)  
#drop lock          
fcntl.flock(f, fcntl.LOCK_UN)

编写器

：

import errno                                                                                    
import fcntl
from time import *

path = "testLock.py"

f = open(path, "r")

while True: 
  try:
    fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
    break   
  except IOError as e:
    if e.errno != errno.EAGAIN:
    raise 
  else:   
    sleep(1)
    print 'Waiting...'

#reader's action      
execfile(path)  
#drop lock          
fcntl.flock(f, fcntl.LOCK_UN)

import errno                                                                                    
import fcntl
from time import *

path = "testLock.py"

f = open(path, "w")

while True: 
  try:
    fcntl.flock(f, fcntl.LOCK_SH | fcntl.LOCK_NB)
    break   
  except IOError as e:
    if e.errno != errno.EAGAIN:
    raise 
  else:   
    sleep(1)
    print 'Waiting...'

#writer's action      
for i in (1,10,2):
  f.write('print "%d" % i')
  sleep(1)  
#drop lock          
fcntl.flock(f, fcntl.LOCK_UN)

我有一些问题：

问题1：使用

LOCK_EX

和

LOCK_SH

是否正确？我的意思是它们在正确的位置吗

---

问题2：读者的行为，即

execfile

是否正确？如果文件已打开，请执行文件是否仍尝试打开？

如果需要并行运行两个脚本，同时确保读/写操作不会同时进行，则可以尝试使用，创建单独的线程并将它们连接起来。您可能希望写入

设置_new.py

，然后在写入完成后，将

settings\u new.py

移动到

settings.py

（覆盖它）。我认为这应该为文件创建一个原子“更新”——许多应用程序（如文本编辑器）都采用这种方法。您的建议很有帮助，但我不知道如何做到这一点：当读卡器打开FIFO时，我希望编写器等待。反之亦然。但若写入程序在当前时刻并没有向FIFO写入，那个么读卡器就不应该等到写入程序准备就绪。