标签: interprocess

最近,当我想在两个进程之间进行通信时,我遇到了使用(pipe | - )的问题.基本上,子进程无法像父进程一样快地处理STDIN.这导致父级等待STDIN空闲并使其运行缓慢.

STDIN有多大,可以修改它.如果是,最佳练习大小是多少？

这是一些代码示例,以显示我的意思:

if ($child_pid = open($child, "|-"))
{
    $child->autoflush(1);

    # PARENT process
    while (1)
    {

             # Read packet from socket save in $packet
             process_packet($packet);

             # forward packet to child
             print $child $packet;
     }
}
else
{
     die "Cannot fork: $!" unless defined $child_pid;
     # CHILD process
     my $line;  

     while($line = <STDIN>)
     {
         chomp $line;
         another_process_packet($line);
     }
}

在这个样本another_process_packet慢于process_packet.我写这样的代码的原因是,我想使用相同的数据来自套接字并实际获得它一次.

提前致谢.

我有许多用Python 2.6编写的脚本,可以任意运行.我想有一个中央脚本收集输出并将其显示在一个日志中.

理想情况下,它将满足这些要求:

• 每个脚本都将其消息发送到同一个"接收器"进行显示.
• 如果第一个脚本尝试发送消息时接收器未运行,则启动它.
• 接收器也可以手动启动和结束.(虽然如果结束,如果另一个脚本尝试发送消息,它将重新启动.)
• 脚本可以按任何顺序运行,甚至可以同时运行.
• 在Windows上运行.多平台更好,但至少它需要在Windows上运行.

我遇到了一些提示:

• os.pipe()
• multiprocess
• 占领一个港口
• mutex
• logging.handlers.SocketHandler (感谢@Dan Head)

从这些作品中,我想我可以拼凑一些东西.只是想知道是否有一种明显的"正确"方式,或者我是否可以从任何人的错误中吸取教训.

所以我尝试用Boost.Process做一些事情,尽管尚未被Boost发行版接受.

最简单的程序看起来像

#include <boost/process.hpp> 
#include <string> 
#include <vector> 

namespace bp = ::boost::process; 

void Hello()
{
    //... contents does not matter for me now - I just want to make a new process running this function using Boost.Process.
} 

bp::child start_child() 
{ 
    std::string exec = "bjam"; 

    std::vector<std::string> args; 
    args.push_back("--version"); 

    bp::context ctx; 
    ctx.stdout_behavior = bp::silence_stream(); 

    return bp::launch(exec, args, ctx); 
} 

int main() 
{ 
    bp::child c = start_child(); 

    bp::status s = c.wait(); 

    return s.exited() ? s.exit_status() : EXIT_FAILURE; 
} 

如何高进程我正在创建执行Hello()函数？

我试图将我的游戏中的玩家信息发送到我的网络客户端,然后被发送到服务器.

目前ClientNetwork - > ClientGame关系是用XML文件保存的.它们以非常高的速度来回读/写.如果您只使用一个XML文件进行此交易,那么有时候会"占用"该文件,当一个人无法读取时会产生一种滞后,因为另一个是恶意编写和重写.

为了解决这个问题,我有两个XML文件.如果它不能读取一个,它将读取另一个.从理论上讲,他们应该同时使用它们,因为它是从一个到另一个的权衡.没达到标准杆.

但我的主要问题只是XML的一般用法非常草率,数十个try-catch语句以确保它们都很开心(而且我个人最喜欢的,尝试抓住尝试捕获 - 我们必须更深入)

我很好奇是否有更好的方法来做这件事.我需要一个可由两个客户端程序访问的静态变量点.我担心会有人说数据库......

我想对任何正在研究这个问题的人说明并偶然发现共享内存非常棒.虽然我必须将所有字符串转换为字符然后转换为字节并逐个读取它们,但总体来说它比处理无法同时读取/写入同一文件的内容要好得多.如果您希望进一步了解它而不是仅仅使用它,请转到此链接,它解释了许多消息传递类型以及如何使用它们.

我似乎遇到了boost :: interprocess :: file_lock的问题

我有基本上的过程1

    boost::interprocess::file_lock test_lock("testfile.csv");
    test_lock.lock();
    sleep(1000);
    test_lock.unlock();

当我在第一个进程正在休眠时运行第二个进程时,我发现我仍然能够读取testfile.csv.更糟糕的是,我甚至可以覆盖它.

我是否误解了file_lock的工作原理？我的印象是,调用.lock()会对文件进行独占锁定,并阻止任何其他进程读取/修改文件.

我有一个Python的机器控制系统,目前看起来大致如此

goal = GoalState()
while True:
    current = get_current_state()
    move_toward_goal(current,goal)

现在,我正试图增加通过网络控制机器的能力.我想写的代码是这样的:

goal = GoalState()
while True:
    if message_over_network():
        goal = new_goal_from_message()
    current = get_current_state()
    move_toward_goal(current,goal)

将这种网络功能添加到我的应用程序中最简单,最Pythonic的方法是什么？套接字可以工作,认为他们并不特别感觉Pythonic.我看过XMLRPC和Twisted,但两者似乎都需要对代码进行重大修改.我也看过ØMQ,但感觉我正在添加一个外部依赖项,它没有提供任何我没有使用套接字的东西.

我并不反对使用我上面提到的任何系统,因为我认为失败可能是我的误解.我只是好奇地处理这个简单,常见的问题的惯用方法.

我的主脚本正在运行

class Blah():
    update=0

    def testthings(function):
        return function(9)

main = Blah()
while True:
    main.update+=1

在主脚本运行时,如何运行独立脚本以访问"主变量"(在我的主脚本中定义)？

像这样的东西会很有用

main = GetMain()
while True:
    main.testthings(lambda x: x)

我有一个进程间队列，该队列通常为空，并且只有一段时间不出现任何东西。在我的一个线程中，我想定义一个while循环，如下所示：

def mythread(queue1):

    while (queue1.get_nowait() != 1):
        #do stuff

直到队列为空，这在我的情况下会很快发生，一直很好。当队列为空时，调用get_nowait（）或get（False）会引发空队列异常。有什么方法可以检查队列而不阻塞并且不引发空异常吗？

使用Apple OS X Cocoa框架,如何在另一个进程的窗口上发布工作表(向下滑动模式对话框)？

编辑:澄清一下:

我的应用程序是进行Subversion版本控制的Finder扩展(http://scplugin.tigris.org/).我的应用程序的一部分是插件(Finder的上下文菜单项); 然而,我的应用程序的大部分是在一个单独的守护进程中.出于几个原因,我们选择将几乎所有代码放入守护进程; 插件只定义菜单本身,Apple-Events定义到守护进程.

有时,守护程序需要提示用户提供进一步的信息.它可以在屏幕上为此抛出一个窗口,但这是破坏性的(随机定位),在我看来这里的工作流程是合法的模态,例如"从菜单中选择一个文件,选择'提交',提供提交注释,做手术."

进程间协作(例如传递某种类型的引用)是可以接受的:两个进程都是我的,但我想避免将表单的代码绑定到主进程中.

不久之前,我有一个简单的进程间通信的想法:一个进程向指针输出一个地址,我将其复制到另一个进程的输入,并更改原始变量.

我这样实现了:

#include <iostream>
#include <cstdio>

using namespace std;

int main()
{
    bool p;
    cin>>p;
    if(p){
        int n;
        n=0;
        cout<<&n;
        cin.get();
            cin.get();
            cout<<n;
        }else{
            int *point,n;
            scanf("%p",&point);
            cout<<point;
            cin>>n;
            *point+=n;
        }
        return 0;
    }

我使用scanf是因为cin抱怨,并且不会编译.我尝试用两个进程运行它,但在我启动第二个实例后,输入指针的地址,如第一个输出的那样,它就冻结了.因为我只能访问Windows,所以我不知道它是否有SIGSEGV,或者它是否做了完全不同的事情.

是不是只是我试图改变另一个进程崩溃的变量的值,还是其他阻止我的东西呢？