相关疑难解决方法(0)

用于在Python中编写多线程应用程序的模块是什么？我知道语言和Stackless Python提供的基本并发机制,但它们各自的优点和缺点是什么？

我试图boilerpipe用Python 运行multiprocessing.这样做是为了解析来自多个来源的RSS源.问题是它在处理一些链接后挂在其中一个线程中.如果我删除池并在循环中运行它,整个流程都有效.

这是我的多处理代码:

proc_pool = Pool(processes=4)
for each_link in data:
    proc_pool.apply_async(process_link_for_feeds, args=(each_link, ), callback=store_results_to_db)
proc_pool.close()
proc_pool.join()

这是我boilerpipe在里面调用的代码process_link_for_feeds():

def parse_using_bp(in_url):
    extracted_html = ""
    if ContentParser.url_skip_p.match(in_url):
        return extracted_html
    try:
        extractor = Extractor(extractor='ArticleExtractor', url=in_url)
        extracted_html = extractor.getHTML()
        del extractor
    except BaseException as e:
        print "Something's wrong at Boilerpipe -->", in_url, "-->", e
        extracted_html = ""
    finally:
        return extracted_html

我对它悬挂的原因一无所知.proc_pool代码中有什么问题吗？

现在我正在开发在Windows上运行的C#app.一些进程是用Python编写的,通过pythonnet(Python for .NET)调用.这些过程计算量很大,所以我想并行完成.

它们是CPU限制的,可以独立处理.

据我所知,有两种可能的方法来实现它:

1. 启动多个Python运行时
   第一种方法是启动多个Python解释器,但似乎不可行.因为pythonnet通常只能管理一个由静态方法初始化的解释器,PythonEngine.Initialize().
   从Python.NET文档:

   嵌入器的重要说明: Python不是自由线程的,它使用全局解释器锁来允许多线程应用程序与Python解释器安全地交互.有关此内容的更多信息,请参见www.python.org网站上的Python C-API文档.
   在托管应用程序中嵌入Python时,您必须像在C或C++应用程序中嵌入Python一样管理GIL.
   在与Python.Runtime命名空间提供的任何对象或API交互之前,调用代码必须通过调用PythonEngine.AcquireLock方法获取Python全局解释器锁.此规则的唯一例外是PythonEngine.Initialize方法,可以在启动时调用,而无需获取GIL.

2. 在Python中使用多处理包
   另一种方法是使用多处理包.根据Python文档,如果代码在Windows上运行以确保生成有限进程,则必须使用以下语句:
   if __name__ == "__main__":
   但是,用Python编写的函数作为模块的一部分,因为它嵌入到.NET中.
   例如,以下代码是可执行的,但无限生成进程.

//C#
static void Main(string[] args)
    {
        using (Py.GIL())
        {
            PythonEngine.Exec(
                "print(__name__)\n" + //output is "buitlins"
                "if __name__ == 'builtins':\n" +
                "   import test_package\n" +  //import Python code below
                "   test_package.async_test()\n"
                );
        }
    }

# Python
import concurrent.futures

def heavy_calc(x):
    for i in range(int(1e7) * x):
        i*2

def async_test():
    # multiprocessing
    with concurrent.futures.ProcessPoolExecutor(max_workers=8) as executor:
        futures = [executor.submit(heavy_calc,x) for x …

我正在尝试在python中找出多线程编程.这是我想要比较串行和并行速度的简单任务.

import threading
import Queue
import time
import math

def sinFunc(offset, n):
  result = []
  for i in range(n):
    result.append(math.sin(offset + i * i))
  return result

def timeSerial(k, n):
  t1 = time.time()    
  answers = []
  for i in range(k):
    answers.append(sinFunc(i, n))
  t2 = time.time()
  print "Serial time elapsed: %f" % (t2-t1)

class Worker(threading.Thread):

  def __init__(self, queue, name):
    self.__queue = queue
    threading.Thread.__init__(self)
    self.name = name

  def process(self, item):
    offset, n = item
    self.__queue.put(sinFunc(offset, n))
    self.__queue.task_done()
    self.__queue.task_done()

  def run(self):
    while 1:
        item …

假设你有这样的东西(从这里复制):

#!/usr/bin/python
from scapy.all import *

TIMEOUT = 2
conf.verb = 0
for ip in range(0, 256):
    packet = IP(dst="192.168.0." + str(ip), ttl=20)/ICMP()
    reply = sr1(packet, timeout=TIMEOUT)
    if not (reply is None):
         print reply.src, "is online"
    else:
         print "Timeout waiting for %s" % packet[IP].src

在尝试下一个主机之前,无需等待每个ping完成.我可以每次将循环内部放入沿着&in 的行的背景中:

for ip in 192.168.0.{0..255}; do 
ping -c 1 $ip &
done