Question

from random import randrange
from time import sleep
#import thread
from threading import Thread
from Queue import Queue
'''The idea is that there is a Seeker method that would search a location
for task, I have no idea how many task there will be, could be 1 could be 100.
Each task needs to be put into a thread, does its thing and finishes. I have
stripped down a lot of what this is really suppose to do just to focus on the
correct queuing and threading aspect of the program. The locking was just
me experimenting with locking'''
class Runner(Thread):
    current_queue_size = 0
    def __init__(self, queue):
        self.queue = queue
        data = queue.get()
        self.ID = data[0]
        self.timer = data[1]
        #self.lock = data[2]
        Runner.current_queue_size += 1
        Thread.__init__(self)

    def run(self):
        #self.lock.acquire()
        print "running {ID}, will run for: {t} seconds.".format(ID = self.ID,
                                                                t = self.timer)
        print "Queue size: {s}".format(s = Runner.current_queue_size)
        sleep(self.timer)        
        Runner.current_queue_size -= 1
        print "{ID} done, terminating, ran for {t}".format(ID = self.ID,
                                                                t = self.timer)
        print "Queue size: {s}".format(s = Runner.current_queue_size)
        #self.lock.release()
        sleep(1)
        self.queue.task_done()

def seeker():
    '''Gathers data that would need to enter its own thread.
    For now it just uses a count and random numbers to assign
    both a task ID and a time for each task'''
    queue = Queue()
    queue_item = {}
    count = 1
    #lock = thread.allocate_lock()
    while (count <= 40):
        random_number = randrange(1,350)
        queue_item[count] = random_number
        print "{count} dict ID {key}: value {val}".format(count = count, key = random_number,
                                                          val = random_number)
        count += 1

    for n in queue_item:
        #queue.put((n,queue_item[n],lock))
        queue.put((n,queue_item[n])) 
        '''I assume it is OK to put a tulip in and pull it out later'''
        worker = Runner(queue)
        worker.setDaemon(True)
        worker.start()
    worker.join() 
    '''Which one of these is necessary and why? The queue object
    joining or the thread object'''

    #queue.join()    

if __name__ == '__main__':
    seeker()

我已将大部分问题都放在代码本身中，但要重点讨论（Python2.7）：

我想确保自己以后不会为自己造成大量内存泄漏。
我注意到当我在putty或VNC上以40的数量运行时我的linuxbox，我并不总是得到所有的输出，但什么时候我在Windows上使用IDLE和Aptana。
是的我明白队列的意思是错开你的意思线程，所以你不会充斥你的系统的内存，但任务在手是时间敏感的，所以他们需要尽快处理无论有多少或几乎没有检测到;我有发现当我有队列时，我可以清楚地决定任务的时间最后反对让垃圾收集者猜测。
我仍然不知道为什么我能够逃脱使用线程或队列对象上的.join（）。
提示，技巧，一般帮助。
感谢您阅读。

Answer 1

如果我理解正确，你需要一个线程来监控某些东西，看是否有需要完成的任务。如果找到任务，您希望该任务与搜索器和其他当前正在运行的任务并行运行。

如果是这种情况，那么我认为你可能会犯这个错误。看一下GIL在Python中的工作原理。我认为你真正想要的是多处理。

从pydocs看一下这个：

CPython实现细节：在CPython中，由于Global Interpreter Lock，只有一个线程可以同时执行Python代码（即使某些面向性能的库可能会克服此限制）。如果您希望应用程序更好地利用多核机器的计算资源，建议您使用多处理。但是，如果要同时运行多个I / O绑定任务，则线程仍然是一个合适的模型。

Python-多线程时间敏感任务

1 个答案: