Tag: 多处理

这真的是从Java代码启动第二个JVM的最好方法吗？

这是我自己以前的问题的一个后续，我有点不好意思问这个…但无论如何：你将如何从一个独立的Java程序以独立于系统的方式启动第二个JVM？ 而且不需要依赖像JAVA_HOME这样的envvariables，因为这可能会指向与当前运行的JRE不同的JRE。 我想出了下面的代码实际上工作，但感觉有点尴尬： public static void startSecondJVM() throws Exception { String separator = System.getProperty("file.separator"); String classpath = System.getProperty("java.class.path"); String path = System.getProperty("java.home") + separator + "bin" + separator + "java"; ProcessBuilder processBuilder = new ProcessBuilder(path, "-cp", classpath, AnotherClassWithMainMethod.class.getName()); Process process = processBuilder.start(); process.waitFor(); } 而且，当前正在运行的JVM可能已经被第二个JVM不知道的其他参数（-D，-X …，…）启动了。

了解多重处理：Python中的共享内存pipe理，locking和队列

多进程是Python中的一个强大的工具，我想更深入地理解它。 我想知道什么时候使用常规的 锁和队列以及何时使用多处理器pipe理器在所有进程之间共享这些。 我想出了四种不同的多处理条件下的testing场景： 使用池和NOpipe理器 使用一个池和一个经理 使用单个进程和NOpipe理器 使用单独的进程和pipe理器 工作 所有的条件执行工作职能the_job 。 the_job包含一些由锁保护的打印。 而且，函数的input只是简单地放入一个队列（查看是否可以从队列中恢复）。 这个input只是在主脚本start_scenario创build的range(10)的索引idx （显示在底部）。 def the_job(args): """The job for multiprocessing. Prints some stuff secured by a lock and finally puts the input into a queue. """ idx = args[0] lock = args[1] queue=args[2] lock.acquire() print 'I' print 'was ' print 'here ' print '!!!!' […]

尝试python多处理的Windows上的RuntimeError

我正在尝试我的第一个正式的Python程序在Windows机器上使用线程和多处理。 我无法启动这个过程，用python给出下面的消息。 事情是，我不在主模块中启动我的线程。 线程在一个类中的独立模块中处理。 编辑 ：顺便说一句，这个代码在Ubuntu上运行良好。 不太在窗户上 RuntimeError: Attempt to start a new process before the current process has finished its bootstrapping phase. This probably means that you are on Windows and you have forgotten to use the proper idiom in the main module: if __name__ == '__main__': freeze_support() … The "freeze_support()" line can be […]

并行化Numpyvector操作

让我们使用，例如， numpy.sin() 以下代码将返回数组a每个值的正弦值： import numpy a = numpy.arange( 1000000 ) result = numpy.sin( a ) 但是我的机器有32个内核，所以我想利用它们。 （对于像numpy.sin()这样的开销可能不值得，但我真正想使用的函数更复杂一些，而且我将使用大量的数据。） 这是最好的（阅读：最聪明或最快）方法： from multiprocessing import Pool if __name__ == '__main__': pool = Pool() result = pool.map( numpy.sin, a ) 还是有更好的方法来做到这一点？

如何在python Tornado服务器的请求中执行多处理？

我正在使用I / O非阻塞python服务器Tornado。 我有一类GET请求可能需要大量的时间才能完成（想想在5-10秒的范围内）。 问题在于Tornado阻塞了这些请求，以便后续的快速请求被保留，直到缓慢的请求完成。 我看着： https : //github.com/facebook/tornado/wiki/Threading-and-concurrency ，得出结论，我想＃3（其他进程）和＃4（其他线程）的组合。 ＃4自己有问题，而当另一个线程正在进行“重型升降”时，我无法得到可靠的控制回到ioloop。 （我认为这是由于GIL和重负载任务具有高CPU负载，并保持远离主Ioloop的控制的事实，但这是一个猜测）。 所以我一直在做原型devise，通过在一个单独的进程中在这些缓慢的GET请求中完成“繁重的任务”，然后在完成请求的过程中将callback放回到Tornado ioloop中。 这释放了ioloop来处理其他请求。 我已经创build了一个简单的例子来演示一个可能的解决scheme，但是很好奇从社区那里得到反馈。 我的问题有两方面：如何简化现行的方法？ 它可能存在哪些缺陷？ 该方法 利用Tornado内置的asynchronous装饰器，允许请求保持打开状态，并继续使用ioloop。 使用python的multiprocessing模块为“繁重”任务生成一个单独的进程。 我第一次尝试使用threading模块，但无法得到任何可靠的控制权交给ioloop。 多核处理似乎也会利用多核。 在主Ioloop进程中使用正在监视multiprocessing.Queue处理的threading模块启动一个“观察者”线程。当完成时，“繁重”任务的结果将会被调用。 这是需要的，因为我需要一种方式来知道重载任务已经完成，同时还能够通知ioloop这个请求已经完成。 确保“监视器”线程经常使用time.sleep time.sleep(0)调用将控制权交给主Ioloop循环，以便继续处理其他请求。 当队列中存在结果时，使用tornado.ioloop.IOLoop.instance().add_callback()从“观察者”线程添加一个callbacktornado.ioloop.IOLoop.instance().add_callback() ，该函数被logging为从其他线程调用ioloop实例的唯一安全方法。 一定要在callback中调用finish()来完成请求并提交回复。 下面是显示这种方法的一些示例代码。 multi_tornado.py是实现上述大纲的服务器， call_multi.py是一个示例脚本，它以两种不同的方式调用服务器来testing服务器。 两个testing都使用3个慢速GET请求和20个快速GET请求来调用服务器。 在打开和closures线程的情况下都显示结果。 在使用“无线程”运行的情况下，3个缓慢的请求块（每个都需要一秒多的时间才能完成）。 20个快速请求中的一些挤入了ioloop中的一些缓慢请求之间（并不完全确定这是怎么发生的，但可能是我在同一台机器上同时运行服务器和客户端testing脚本的工件）。 这里的要点是，所有的快速请求都受到不同程度的影响。 在使用线程运行的情况下，20个快速请求全部首先立即完成，然后三个慢速请求几乎在同一时间完成，因为它们各自并行运行。 这是所需的行为。 三个缓慢的请求需要2.5秒才能并行完成 – 而在非线程的情况下，三个缓慢的请求总共花费约3.5秒。 所以整体上大概有35％的速度（我认为是由于多核共享）。 但更重要的是 – 快速的请求立即在缓慢的请求中处理。 我没有很多的multithreading编程经验 – 所以虽然这似乎在这里工作，我很好奇学习： 有一个更简单的方法来完成这个吗？ 在这种方法中可能会潜伏什么？ （注意：未来的折衷可能是运行更多的Tornado实例，并使用像nginx这样的反向代理来进行负载均衡，无论我将使用负载均衡器运行多个实例 – 但是我只关心在这个问题上抛硬件因为看起来硬件在阻塞方面与问题直接相关）。 […]

操作系统调度程序如何重新获得CPU的控制权？

我最近开始学习CPU和操作系统是如何工作的，而且我对使用提供多任务操作系统的单CPU机器的操作有些困惑。 因此，假设我的机器只有一个CPU，这意味着在任何时候只有一个进程可以运行。 现在，我只能假定操作系统用来控制访问贵重CPU时间的调度程序也是一个过程。 因此，在这台机器中，用户进程或调度系统进程在任何给定的时间点运行，但不是两者都运行。 所以这是一个问题： 一旦调度程序将CPU的控制权交给另一个进程，又如何重新获得CPU时间来再次运行以执行其调度工作呢？ 我的意思是，如果当前正在运行的任何进程没有放弃（产生）CPU，那么调度器本身如何再次运行并确保正确的多任务处理呢？ 到目前为止，我一直在想，如果用户进程通过系统调用请求I / O操作，那么在系统调用中，我们可以确保调度器再次分配一些CPU时间。 但我甚至不确定这是否有效。 另一方面，如果用户进程本质上是CPU限制的，那么从这个angular度来看，它可以永远运行，从不让其他进程，甚至是调度器再次运行。 假设一个时间片调度，我不知道如何调度程序可以分割执行另一个进程的时间，甚至没有运行？ 我真的很感谢你在这方面可以提供的任何见解或参考。

如何在Python中使用多处理队列？

我在试图了解多处理队列如何在python上工作以及如何实现它时遇到了很多麻烦。 比方说，我有两个Python模块，从共享文件访问数据，让我们称这两个模块作家和读者。 我的计划是让读写器都将请求放入两个单独的多处理队列中，然后让第三个进程在一个循环中popup这些请求并执行。 我的主要问题是，我真的不知道如何正确地实现multiprocessing.queue，你不能真正实例化每个进程的对象，因为它们将是单独的队列，你如何确保所有进程与共享队列相关（或在这种情况下，队列）

如何在多处理器系统上产生并行subprocess？

我有一个Python脚本，我想用作另一个Python脚本的控制器。 我有一个有64个处理器的服务器，所以想要产生多达64个这个第二个Python脚本的subprocess。 子脚本被调用： $ python create_graphs.py –name=NAME NAME是像XYZ，ABC，NYU等 在我的父母控制器脚本中，我从列表中检索名称variables： my_list = [ 'XYZ', 'ABC', 'NYU' ] 所以我的问题是，什么是最好的方式来产生这些进程作为孩子？ 我想把孩子的数量限制在64个，所以需要跟踪状态（如果孩子的过程已经完成了），所以我可以有效地保持整个一代的运行。 我考虑使用subprocess包，但拒绝它，因为它一次只产生一个孩子。 我终于find了多处理器软件包，但是我承认被整个线程和subprocess文档所淹没。 现在，我的脚本使用subprocess.call来一次只产生一个孩子，看起来像这样： #!/path/to/python import subprocess, multiprocessing, Queue from multiprocessing import Process my_list = [ 'XYZ', 'ABC', 'NYU' ] if __name__ == '__main__': processors = multiprocessing.cpu_count() for i in range(len(my_list)): if( i < processors ): cmd = […]

Python进程池非守护进程？

是否有可能创build一个非守护进程的Python池？ 我想要一个池可以调用一个内部有另一个池的函数。 谢谢。

execv（）和fork（）的时间浪费

我目前正在学习有关fork()和execv() ，我有一个关于组合效率的问题。 我被显示了以下标准代码： pid = fork(); if(pid < 0){ //handle fork error } else if (pid == 0){ execv("son_prog", argv_son); //do father code 我知道fork()克隆整个进程（复制整个堆等）， execv()用新程序replace当前的地址空间。 考虑到这一点，使用这种组合不是很低效吗？ 我们正在复制一个进程的整个地址空间，然后立即覆盖它。 所以我的问题是： 即使我们有浪费，使用这个组合（而不是其他一些解决scheme）可以使人们仍然使用这个组合的优点是什么？