相关疑难解决方法(0)

我对Python和多线程编程很新.基本上,我有一个脚本,将文件复制到另一个位置.我希望将它放在另一个线程中,以便我可以输出....以指示脚本仍在运行.

我遇到的问题是,如果文件无法复制,它将引发异常.如果在主线程中运行,这是可以的; 但是,具有以下代码不起作用:

try:
    threadClass = TheThread(param1, param2, etc.)
    threadClass.start()   ##### **Exception takes place here**
except:
    print "Caught an exception"

在线程类本身,我试图重新抛出异常,但它不起作用.我看到这里的人问类似的问题,但他们似乎都在做一些比我想做的更具体的事情(而且我不太了解提供的解决方案).我见过人们提到使用它sys.exc_info(),但我不知道在哪里或如何使用它.

非常感谢所有帮助!

编辑:线程类的代码如下:

class TheThread(threading.Thread):
    def __init__(self, sourceFolder, destFolder):
        threading.Thread.__init__(self)
        self.sourceFolder = sourceFolder
        self.destFolder = destFolder

    def run(self):
        try:
           shul.copytree(self.sourceFolder, self.destFolder)
        except:
           raise

这可能是在类似的背景下提出的,但是在搜索约20分钟后我无法找到答案,所以我会问.

我编写了一个Python脚本(比方说:scriptA.py)和一个脚本(比如说scriptB.py)

在scriptB中我想用不同的参数多次调用scriptA,每次运行大约需要一个小时,(它是一个巨大的脚本,做了很多东西......不用担心它)我希望能够运行scriptA同时具有所有不同的参数,但我需要等到所有这些都完成后再继续; 我的代码:

import subprocess

#setup
do_setup()

#run scriptA
subprocess.call(scriptA + argumentsA)
subprocess.call(scriptA + argumentsB)
subprocess.call(scriptA + argumentsC)

#finish
do_finish()

我想同时运行所有subprocess.call(),然后等到它们全部完成,我该怎么做？

我试着像这里的例子一样使用线程:

from threading import Thread
import subprocess

def call_script(args)
    subprocess.call(args)

#run scriptA   
t1 = Thread(target=call_script, args=(scriptA + argumentsA))
t2 = Thread(target=call_script, args=(scriptA + argumentsB))
t3 = Thread(target=call_script, args=(scriptA + argumentsC))
t1.start()
t2.start()
t3.start()

但我不认为这是对的.

在我去之前我怎么知道他们都跑完了do_finish()？

这可能是一个愚蠢的问题,但我正在测试我对Python的一些假设,我很困惑为什么以下代码片段在线程中调用时不会退出,但在主线程中调用时会退出.

import sys, time
from threading import Thread

def testexit():
    time.sleep(5)
    sys.exit()
    print "post thread exit"

t = Thread(target = testexit)
t.start()
t.join()
print "pre main exit, post thread exit"
sys.exit()
print "post main exit"

sys.exit()的文档声明调用应该从Python退出.我可以从这个程序的输出中看到"post thread exit"永远不会被打印出来,但是主线程在线程调用exit之后仍然继续运行.

是否为每个线程创建了一个单独的解释器实例,而对exit()的调用只是退出该单独的实例？如果是这样,线程实现如何管理对共享资源的访问？如果我确实想要从线程中退出程序(不是我真的想要,但我只是理解)该怎么办？

如果我有一个无限循环的线程,有没有办法在主程序结束时终止它(例如,当我按Ctrl+ C)？

在我的代码中有一个与套接字相关的函数调用,该函数来自另一个模块,因此无法控制,问题是它偶尔会阻塞几个小时,这是完全不可接受的,我如何限制代码中的函数执行时间？我想解决方案必须使用另一个线程.

我在这里尝试做的是使用键盘中断退出程序中所有正在进行的线程.这是我的代码的简化版本,其中创建了线程:

for i in taskDictionary:
    try:
        sleep(60)
        thread = Thread(target = mainModule.executeThread)
        thread.start()
    except KeyboardInterrupt:
        thread.__stop()

程序本身要复杂得多,占据了影响线程的大量不同变量,甚至可以选择以顺序模式启动,其中任务没有线程化,而是逐个启动,因此可能存在一些问题我只是想起了这个小小的变化.我以产生50/50结果的方式完成了这项工作.中断可以工作,但线程永远不会干净地退出.有时它们会继续运行但是停止执行未来的线程,有时候它们会因为中断的大量错误而退出,有时中断根本不会执行任何操作.上次我运行它时,程序停止执行任何未来的线程,但没有停止当前线程.有没有办法退出线程而不进入线程实际执行的模块？

我在某处读到KeyboardInterrupt异常只在Python的主线程中引发.我还读到在子线程执行时主线程被阻塞.那么,这是否意味着CTRL+ C永远不会到达子线程.我尝试了以下代码:

def main():
    try:
        thread = threading.Thread(target=f)
        thread.start()  # thread is totally blocking (e.g., while True)
        thread.join()
    except KeyboardInterrupt:
        print "Ctrl+C pressed..."
        sys.exit(1)

def f():
    while True:
        pass  # do the actual work

在这种情况下,CTRL+ C对执行没有影响.它就像是无法收听信号.我理解这是错误的方式吗？有没有其他方法可以使用CTRL+ 杀死线程C？

我正在编写一个应用程序,它将行添加到多个线程的同一文件中.

我有一个问题,其中一些行没有新行.

对此有何解决方案？

class PathThread(threading.Thread):
    def __init__(self, queue):
        threading.Thread.__init__(self)
        self.queue = queue

    def printfiles(self, p):
        for path, dirs, files in os.walk(p):
            for f in files:
                print(f, file=output)

    def run(self):
        while True:
            path = self.queue.get()
            self.printfiles(path)
            self.queue.task_done()


pathqueue = Queue.Queue()
paths = getThisFromSomeWhere()

output = codecs.open('file', 'a')

# spawn threads
for i in range(0, 5):
    t = PathThread(pathqueue)
    t.setDaemon(True)
    t.start()

# add paths to queue
for path in paths:
    pathqueue.put(path)

# wait for queue to get empty
pathqueue.join()

我用urllib2的是build_opener()创造一个OpenerDirector.我正在使用它OpenerDirector来获取慢速页面,因此它有一个很大的超时.

到现在为止还挺好.

但是,在另一个线程中,我被告知要中止下载 - 假设用户已经选择退出GUI中的程序.

有没有办法发出urllib2下载应该退出的信号？

我有一些代码需要针对可能挂起或有不受我控制的问题的其他几个系统运行.我想使用python的多处理来生成子进程独立于主程序运行,然后当它们挂起或有问题终止它们时,但我不确定最好的方法来解决这个问题.

当终止被调用时,它确实会终止子进程,但它会变成一个已经失效的僵尸,直到进程对象消失才会被释放.循环永远不会结束的下面的示例代码可以杀死它并在再次调用时允许重新生成,但似乎不是一个很好的解决方法(即multiprocessing.Process()在__init __()中会更好.

有人有建议吗？

class Process(object):
    def __init__(self):
        self.thing = Thing()
        self.running_flag = multiprocessing.Value("i", 1)

    def run(self):
        self.process = multiprocessing.Process(target=self.thing.worker, args=(self.running_flag,))
        self.process.start()
        print self.process.pid

    def pause_resume(self):
        self.running_flag.value = not self.running_flag.value

    def terminate(self):
        self.process.terminate()

class Thing(object):
    def __init__(self):
        self.count = 1

    def worker(self,running_flag):
        while True:
            if running_flag.value:
                self.do_work()

    def do_work(self):
        print "working {0} ...".format(self.count)
        self.count += 1
        time.sleep(1)