标签: interprocess

我需要在进程之间共享一堆字符串(将来可能会有更复杂的对象).我决定使用boost :: interprocess但我无法使用它.我确定这是因为我不理解某些事情.我按照他们的例子,但如果有经验使用该库的人可以查看我的代码并告诉我什么是错的,我将非常感激.问题是它似乎有效,但经过几次迭代后,我在阅读器进程和有时在编写器进程上都会遇到各种异常.这是我的实现的简化版本:

using namespace boost::interprocess;
class SharedMemoryWrapper
{
public:
    SharedMemoryWrapper(const std::string & name, bool server) :
      m_name(name),
      m_server(server)
    {
        if (server)
        {
            named_mutex::remove("named_mutex");
            shared_memory_object::remove(m_name.c_str());
            m_segment = new managed_shared_memory (create_only,name.c_str(),65536);         
            m_stackAllocator = new StringStackAllocator(m_segment->get_segment_manager());
            m_stack = m_segment->construct<StringStack>("MyStack")(*m_stackAllocator);
        }
        else
        {
            m_segment = new managed_shared_memory(open_only ,name.c_str());
            m_stack = m_segment->find<StringStack>("MyStack").first;
        }
        m_mutex = new named_mutex(open_or_create, "named_mutex");
    }

    ~SharedMemoryWrapper()
    {
        if (m_server)
        {
            named_mutex::remove("named_mutex");
            m_segment->destroy<StringStack>("MyStack");
            delete m_stackAllocator;
            shared_memory_object::remove(m_name.c_str());
        }
        delete m_mutex;
        delete m_segment;
    }

    void push(const std::string & in)
    {
        scoped_lock<named_mutex> lock(*m_mutex);
        boost::interprocess::string …

我一直在研究使用Boost.Interprocess来创建磁盘支持的数据结构.Boost文档(http://www.boost.org/doc/libs/1_41_0/doc/html/interprocess.html)上的示例都是为了使用共享内存,即使他们提到也可以使用内存映射文件.我想知道这里是否有人使用过内存映射文件？任何可公开获得的代码示例(例如,内存映射文件支持的映射或集)？

我正在处理一些进程间通信的东西，我很好奇是否可以将函数复制到某些共享内存中并从任一进程中运行它。

就像是：

memcpy(shared_memory_address, &func, &func + sizeof(func));

我知道你无法确定函数的大小，但这就是我脑海中突然浮现的想法。

在 C# 中使用命名管道进行进程间通信很容易，但我不确定如何在 php 中执行此操作，或者是否可能。所以我有这些问题：

1. php 中可以使用命名管道吗？
2. 是否可以有一个 C# 命名管道客户端连接到 php 命名管道服务器？
3. 我到底要怎么编码呢？:)

对上述任何问题的回答都会非常有帮助..谢谢:)

编辑：它是一个独立的 php 程序，而不是基于网络的应用程序。

edit2：命名管道服务器可以在C#端，也可以在PHP端，这并不重要。我已经为两者制作了 C# 示例..但我不知道从哪里开始 php

我有一个进程外的COM服务器,需要密切关注事物.此服务器作为服务运行,并且在内部是单例.为简单起见,我会称他为BossCom.

我有另一个进程外COM服务器,它是一个工作者.对于系统稳定性而言,它是一次性服务器(意味着如果您创建2个WorkerCom,则有2个WorkerCom.exe正在运行).为简单起见,我会称他为WorkerCom.

WorkerCom可以通过任何东西启动,即使有人通过命令行使用正确的命令行参数运行他也可以启动它.

总体目标是让BossCom知道什么是WorkerComs,知道他们在做什么,并能够给他们订单(暂停,停止,加速等).

我最初的想法是,每当WorkerCom启动时,他都会CoCreateInstance一个BossCom并调用BossCom-> RegisterWorker(IUnknown me).然后当WorkerCom即将关闭时,他会调用BossCom-> UnregisterWorker(IUnknown me).BossCom可以为IWorkerCom查询IUnknown,并能够发出命令.

如果所有这些com对象都在同一个进程中,那将会很有效,但它们不是.我想过使用GlobalInterfaceTable,但它只是单个进程意义上的全局.

我花了几天时间研究这个并且不知所措.也许我是隧道视野.

如何编组从Worker到Boss的com对象的引用？

哦,而且,值得一提的是,BossCom是用C#编写的,而WorkerCom是用ATL C++编写的,但我会用VB,Scala,Lisp等编写的解决方案.我想我可以翻译核心理念.:-)

我还没有找到一个很好的例子来展示如何使用 boost::interprocess:: named_semaphore（甚至在 Boost 网站上都没有）。

我可以看到有关 interprocess_semaphore 的一些信息，但它们似乎完全不同，我不知道为一个显示的内容是否也适用于另一个。

任何人都可以给我一些此类示例/教程/文档的链接吗？

谢谢你。

我正在使用 boost::interprocess::scoped_lock，如果应用程序由于某种原因在范围内崩溃，则不会释放互斥锁。下次执行应用程序时（无需重新启动计算机），互斥锁被锁定。

这是如何工作的？我给出了下面代码的一个简单示例。

{
    boost::interprocess::named_mutex lockMutex(boost::interprocess::open_or_create, "lockName");
    boost::interprocess::scoped_lock<boost::interprocess::named_mutex> lock(lockMutex);
    //crash here
}

我最终做了如下超时。谁能想出一个不限制锁定时间的解决方案？

boost::interprocess::named_mutex named_mtx(boost::interprocess::open_or_create, lockName.c_str());

    while(true)
    {
        if(named_mtx.try_lock())
        {
            break;
        }

        if(!named_mtx.timed_lock(boost::get_system_time() + boost::posix_time::milliseconds(TIMEOUT_MILLISECONDS)))
        {
            named_mtx.unlock();
        }
    }

Boost 版本 - 1.47 我找不到 boost::interprocess::interprocess_sharable_mutex，但看起来它是向前声明的。这真的支持吗？

我可以看到 boost::interprocess::interprocess_upgradable_mutex 是向前声明的，并且也被定义了。但是，我无法找到可以使用此互斥体的相应条件变量。有任何想法吗 ？

我正在尝试将视频和音频数据流式传输到Windows 上的两个独立命名管道中。

ffmpeg.exe -f dshow -i video="My camera name":audio="My microphone name" -map 0:1 -ac 1 -f f32le \\.\pipe\audioStream -map 0:0 -f mjpeg \\.\pipe\videoStream

问题是 FFMPEG 似乎不理解输出\\.\pipe\audioStream和\\.\pipe\videoStream管道并将它们视为文件。

1. 如果管道在 FFMPEG 启动时已经创建，它想覆盖它们并失败。
2. 否则，它会抱怨路径不存在并失败。

据我所知，指定pipe:协议应该可以解决问题，但我无法弄清楚如何正确使用它，即使使用单个管道也是如此。我试过了：

1. pipe:pipeName
2. pipe:pipe\pipeName
3. pipe:\\.\pipe\pipeName
4. pipe://pipeName
5. pipe://pipe\pipeName
6. pipe://\\.\pipe\pipeName

我总是得到相同的结果：输出被写入控制台而不是管道。如果管道在 FFMPEG 启动时已经存在，则没有任何连接到管道。

是否可以在 Windows 上将 FFMPEG 与命名管道一起使用？如果是，那么执行此操作的正确方法是什么？

我有超过 3 个 java 进程访问同一文件进行读写。每个进程都有多个线程，对文件的读写非常频繁（1秒10次左右）。

我用于java.nio.channels.FileLock进程间文件锁定。以及commonObj.wait() commonObj.notify()线程间同步。

我在此实施中面临的问题是 -

1. java.io.IOException: Resource deadlock avoided其中一个进程发生异常。
2. 进程的文件读取器线程之一获取空文件可能是因为其他某个线程或进程正在写入文件。

我的问题是，

1. 如果线程在读取或写入完成后立即释放文件锁，那么为什么会出现问题 1？
2. 如果文件在读取或写入之前被所有进程的每个线程锁定，那么为什么会出现 2 个问题？

我已经为所有 java 进程编写了通用的读写器类。附上一样的。

package json_file_handler;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.channels.OverlappingFileLockException;
import java.util.concurrent.locks.ReentrantLock;

import org.apache.log4j.Logger;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;

public class JsonReader {
   
	final static Logger logger = Logger.getLogger(JsonReader.class);
	static final ReentrantLock relock = new ReentrantLock();
      
	/**
	 * Read given file …