标签: multiprocess

我们被告知Google Chrome会在单独的流程中运行每个标签.因此,一个选项卡中的崩溃不会导致其他选项卡出现问题.

AFAIK,多进程主要用于没有GUI的程序.我从来没有读过任何可以将多个GUI流程嵌入到单个GUI流程中的技术.

Chrome是如何做到的？

我问这个问题是因为我正在设计CCTV软件,它将使用来自多个相机制造商的视频解码SDK,其中一些远非稳定.所以我更喜欢在不同的流程中运行这些SDK,我认为这与Chrome类似.

我有10个以上的任务要执行,系统限制最多可以同时运行4个任务.

我的任务可以像:myprog taskname一样启动

如何编写bash shell脚本来运行这些任务.最重要的是,当一个任务完成时,脚本可以立即启动另一个任务,使运行任务计数始终保持为4.

我有一个python应用程序,它抓取数据集合,对于该集合中的每个数据,它执行一项任务.由于涉及延迟,该任务需要一些时间才能完成.由于这种延迟,我不希望每个数据随后执行任务,我希望它们全部并行发生.我应该使用多进程吗？或操作线程？

我试图使用线程,但遇到了一些麻烦,通常一些任务实际上永远不会触发.

我是多线程/流程编程的新手.所以这就是我需要澄清的内容.

处理代码

pthread_mutex_lock()
    pthread_create(fooAPI(sharedResource)) //fooAPI creates another thread with shared resource that shares across processes.
pthread_mutex_unlock()

使用上面的伪代码,sharedResource如果未解锁互斥锁,进程B是否能够访问？

如何正确访问进程B中的sharedResource？

有没有明确的可视图解释互斥体,线程和进程之间的关系？

我正在实现一个使用不同内核的多线程程序,并且同时执行许多线程.每个线程都进行一次printf()调用,结果不可读.

我如何制作printf()原子,以便printf()一个线程中的printf()调用与另一个线程中的调用不冲突？

我在寻找一个明确的答案(如果确实存在)有多少内存应该通过创建共享内存的静态块时被分配boost::interprocess的managed_shared_memory.即使是官方的例子似乎也会分配任意大块的内存.

考虑以下结构:

// Example: simple struct with two 4-byte fields
struct Point2D {
  int x, y;
};

我最初的反应是必要的大小是8个字节,或者sizeof(Point2D).当我尝试构造一个对象时,这会失败,在运行时给出了seg-fault.

// BAD: 8 bytes is nowhere near enough memory allocated.
managed_shared_memory segment(create_only, "My shared memory", sizeof(Point2D));

什么读/写操作导致seg-faults？堆栈操作？临时分配segment.construct()？分配共享内存时需要多少开销？

通过试错我发现,通过4大小乘可以为上述结构的工作,但是当我开始增加更多的领域,以我的分崩离析struct.所以,这是一个糟糕的黑客.

有些人可能会争辩说,"内存很便宜",在现代电脑,但我不同意这种理念和分配不喜欢比我更需要的,如果我能避免它.我昨天在Boost文档中挖了一遍,找不到任何建议.这是今天要学习新东西的!

请考虑如下课程:

class Foo:
    def __init__(self, data):
        self.data = data

    def do_task(self):
        #do something with data 

在我的应用程序中,我有一个包含几个Foo类实例的列表.目的是执行do_task所有Foo对象.第一个实现很简单:

 #execute tasks of all Foo Object instantiated
 for f_obj in my_foo_obj_list:
     f_obj.do_task()

我想利用多核架构共享for我机器的4个CPU之间的循环.

最好的方法是什么？

假设我想要对一些密集计算(不是I/O绑定)进行并行化.

当然,我不想运行比可用处理器更多的进程,或者我会开始支付上下文切换(和缓存未命中).

精神上,我希望随着我增加n中multiprocessing.Pool(n),总时间将这样的表现:

1. 负斜率作为任务利用并行化
2. 上下文切换的正斜率开始使我付出代价
3. 高原

但实际上,我得到了这个:

#!/usr/bin/env python

from math import factorial


def pi(n):
    t = 0
    pi = 0
    deno = 0
    k = 0
    for k in range(n):
        t = ((-1)**k)*(factorial(6*k))*(13591409+545140134*k)
        deno = factorial(3*k)*(factorial(k)**3)*(640320**(3*k))
        pi += t/deno
    pi = pi * 12/(640320**(1.5))
    pi = 1/pi
    return pi

import multiprocessing
import time
maxx = 20
tasks = 60
task_complexity = 500
x = range(1, maxx+1)
y = [0]*maxx

for i in x:
    p = …

Python concurrent.futures和ProcessPoolExecutor提供了一个简洁的界面来安排和监视任务.期货甚至提供 .cancel()方法:

cancel():尝试取消通话.如果当前正在执行调用且无法取消,则该方法将返回False,否则将取消调用并且该方法将返回True.

不幸的是,在一个类似的问题(关于asyncio)中,回答声称运行任务是不可取消的,使用这个剪切的文档,但文档不要说,只有它们运行和不可解决.

向进程提交multiprocessing.Events也是不可能的(通过参数执行此操作,如在multiprocess.Process中返回RuntimeError)

我想做什么？我想分区搜索空间并为每个分区运行任务.但它足以拥有一个解决方案,而且这个过程是CPU密集型的.那么有一种实际的舒适方式可以通过使用ProcessPool开始来抵消收益吗？

例:

from concurrent.futures import ProcessPoolExecutor, FIRST_COMPLETED, wait

# function that profits from partitioned search space
def m_run(partition):
    for elem in partition:
        if elem == 135135515:
            return elem
    return False

futures = []
# used to create the partitions
steps = 100000000
with ProcessPoolExecutor(max_workers=4) as pool:
    for i in range(4):
        # run 4 tasks with a partition, but only *one* solution is needed
        partition = range(i*steps,(i+1)*steps) …

我有一小部分工人(4)和一大堆任务(5000~).我正在使用池并使用map_async()发送任务.因为我正在运行的任务相当长,所以我强制执行1的chunksize,这样一个长进程就无法阻止一些较短的进程.

我想做的是定期检查剩下的任务数量.我知道最多4个会活跃,我关心有多少人要处理.

我用Google搜索过,我找不到任何人这样做.

一些简单的代码可以帮助:

import multiprocessing
import time

def mytask(num):
    print('Started task, sleeping %s' % num)
    time.sleep(num)

pool = multiprocessing.Pool(4)
jobs = pool.map_async(mytask, [1,2,3,4,5,3,2,3,4,5,2,3,2,3,4,5,6,4], chunksize=1)
pool.close()

while True:
    if not jobs.ready():
        print("We're not done yet, %s tasks to go!" % <somethingtogettasks>)
        jobs.wait(2)
    else:
        break