相关疑难解决方法(0)

我有一个GNU Radio应用程序,它使用Python和C++代码.我希望能够发出事件的C++代码信号.如果它们在相同的范围内,我通常会使用一个简单的布尔值,但代码与需要某种形式的共享内存的点是分开的.有问题的代码对性能至关重要,因此需要一种有效的方法.

我最初考虑的是Python和C++都可以访问的共享内存段.因此,我可以在python代码中设置一个标志,并从C++中检查它.由于我只需要一个简单的标志来暂停C++代码,信号量就足够了吗？

为了清楚起见,我需要从Python设置一个标志,C++代码将只检查这个标志,如果设置了,则进入一个繁忙的循环.

那么尝试在Python/C++之间实现共享内存段是一种合理的方法吗？信号量怎么样？在Linux上,哪个更容易实现？

谢谢!

关于在追加模式下打开文件然后尝试寻找文件的开头,我遇到了这种奇怪的行为.

代码应该是不言自明的:在第二次打开时,我希望能够将一个字符串写入文件的开头,然后f.tell()返回5(在文件开头写入的字节数).

问题是,在Python 2.6.6和2.7.6中,最终的断言触发,但令人惊讶的是,它在Python 3.3.2中有效.

# Create new file, write after the 100th byte.
f = open("test", "w+b")
f.seek(100, 0)
f.write(b"end")
assert f.tell() == 100 + len("end")
f.close()

# Open file for writing without overwriting, attempt to write at start of file
# of the file, but doesn't.
f = open("test", "a+b")
f.seek(0, 0)
f.write(b"start")
assert f.tell() == len("start")
f.close()

所以我做了一个相同的C程序.它实际上表现得像Python 2.x版本:

#include <stdio.h>

int main() {
  FILE *f = fopen("tt", "w+b");
  fseek(f, 100, 0);
  fwrite("x", 1, 1, …

Pythonmultiprocessing模块有一个用于可重入/递归锁的类：

from multiprocessing import RLock

l = RLock()
l.acquire()
l.acquire()
l.release()
l.release()

这对于从公共父进程分叉的进程非常有用，因此可以共享相同的RLock对象。但是，对于具有独立进程的情况（例如：Web 服务器 + cron 作业），需要一个命名锁。不幸的是，RLock()不接受锁的名称参数。有没有允许做这样的事情的解决方案？

l = RLock('mylock')
l.acquire()
l.release()

https://pypi.python.org/pypi/lockfile/0.12.2声明:

不推荐使用此软件包.高度优选的是,代替使用这种代码库,而不是fasteners_或oslo.concurrency用于代替

但是,fasteners很明显,这不是线程安全的:

(http://fasteners.readthedocs.org/en/latest/)

警告:不保证单个进程中多个线程的使用

我找不到使用的例子oslo.concurrency.

还有一些建议使用flock可以解决这种情况,但flock手册指出:

(https://www.freebsd.org/cgi/man.cgi?query=flock&sektion=2)

flock系统调用应用或删除与文件描述符fd关联的文件的建议锁.通过指定LOCK_SH或LOCK_EX之一的操作参数以及可选的LOCK_NB添加来应用锁定.要解锁现有的锁定操作,应该是LOCK_UN.

通知锁允许协作进程对文件执行一致的操作,但不保证一致性(即,进程仍可访问文件而不使用可能导致不一致的建议锁).

所以...

这是一个python程序,它需要在其上实现的函数lock和unlock函数,以防止在一个进程的一个实例中由多个线程实现该操作.

(提示:启动时python test.py 1 & python test.py 2 & python test.py 3)

我如何修复此代码以使其正常工作？

import sys
import time
import random
import threading

def lock():
  pass  # Something here?

def unlock():
  pass  # Something here?

def action(i):
  lock()
  id = threading.current_thread()
  pid = sys.argv[1]
  print("\n")
  for i …

编辑：太多的信息会分散人们的注意力，所以我几乎删除了所有内容。这是在 Windows 上，Python 3.6 使用 mmap 和 msvcrt

一个 python 应用程序中的代码：

fd = os.open(r'C:\somefile', os.O_CREAT | os.O_RDWR)
mm_file = mmap.mmap(fd, 4096, access=mmap.ACCESS_WRITE)
msvcrt.locking(fd, msvcrt.LK_LOCK, 4096)

当第二个应用程序尝试打开 C:\somefile 进行读/写时，预期会收到某种错误消息，表明它无法访问它，因为它已被锁定。

实际发生的情况：第二个应用程序访问它没有问题。

我有两个 python 程序，它们应该并行运行并执行相同的操作：

1. 从磁盘读取并解压缩数据（大约需要 1 分钟）
2. 处理数据（大约需要2-3分钟）
3. 将数据发送到数据库（大约需要3-5分钟）

正如您所看到的，最好以一种方式同步两个实例的执行，其中一个执行处理器密集型步骤 1 和 2（实现是多线程的，因此 CPU 实际上可以达到最大），而另一个则执行I/O 密集型步骤 3，反之亦然。

我的第一个想法是使用锁文件，每个进程在进入第 3 阶段时都会获取该锁文件，并在完成阶段后释放它。因此，另一个进程将等待锁被释放，然后在进入阶段 3 时设置它。但是，这似乎是一种非常麻烦的方法。此外，系统应该在无人监管的情况下运行数天或数周，并能够从错误、计划重启或电源故障中恢复。特别是在最后一种情况下，锁文件可以简单地锁定所有内容。

有没有更优雅的方式来在两个进程之间传达锁定？或者我应该使用锁文件并尝试实现一些智能清理功能以防止发生死锁？