在Python中为for循环使用线程 item_list=[（“a”，10，20），（“b”，25，40），（“c”，40100），（“d”，45，90）， （“e”，35，65），（“f”，50，110）]#重量/值 结果=[（“”，0，0）]#一个空字符串和一个2元组，用于与新的 #价值观 类背包（对象）： 定义初始化（self，B）： self.B=B#B=最大重量 self.pack（项目列表，0，（“”，0，0）） def包（自身、项目、n、当前）： n+=1#n递增，以停止递归（如果所有 如果n>=len（项目）-1： 如果当前[2]>结果[0][2]： #如果电流更大且无启动，则替换结果 #新递归 结果[0]=当前值 其他： 对于项目中的i： 如果当前[1]+i[1]结果为[0][2]： 结果[0]=当前值

背囊1=背囊（100）

这是背包问题的一个小算法。我必须以某种方式将代码并行化，但到目前为止我还没有得到线程模块。我认为使用并行化的唯一地方是for循环，对吗？所以，我试过这个：

item_list = [("a", 10, 20), ("b", 25, 40), ("c", 40, 100), ("d", 45, 90),
             ("e", 35, 65), ("f", 50, 110)] #weight/value
results = [("", 0, 0)]  #an empty string and a 2-tupel to compare with the new
                        #values

class Rucksack(object):
    def __init__(self, B):
        self.B = B   #B=maximum weight
        self.pack(item_list, 0, ("", 0, 0))

    def pack(self, items, n, current):  
        n += 1   #n is incremented, to stop the recursion, if all
        if n >= len(items) - 1:
            if current[2] > results[0][2]:
                #substitutes the result, if current is bigger and starts no
                #new recursion
                results[0] = current
        else:
            for i in items:
                if current[1] + i[1] <= self.B and i[0] not in current[0]:
                    #first condition: current + the new value is not bigger
                    #than B; 2nd condition: the new value is not the same as
                    #current
                    i = (current[0] + " " + i[0], current[1] + i[1],
                         current[2] + i[2])
                    self.pack(items, n, i)
                else:
                    #substitutes the result, if current is bigger and starts no
                    #new recursion
                    if current[2] > results[0][2]:
                        results[0] = current

def运行（自身、项目、i、n、当前）：
全局线程数，线程数已启动
lock.acquire（）
线程数+=1
线程\u已启动=真
lock.release（）
如果当前[1]+i[1]结果为[0][2]：
结果[0]=当前值
lock.acquire（）
线程数-=1
lock.release（）

---

但结果很奇怪。什么都没有发生，如果我做了一个键盘中断，结果是正确的，但这肯定不是实现的意义。你能告诉我第二个代码有什么问题吗？或者我还能在哪里合理地使用perallelisation。谢谢。

首先，由于您的代码受到CPU的限制，所以使用线程进行并行处理的好处微乎其微，正如bereal所解释的。幸运的是，线程和进程之间只有一些区别，基本上，所有共享数据都必须显式地传递或共享（有关详细信息，请参阅）

第二，如果您想要数据并行化您的代码，您必须锁定对可变共享对象的所有访问。快速看一眼，虽然

项目

和

当前

看起来是不可变的，但是

结果

对象是一个共享全局对象，您可以在所有地方修改它。如果您可以更改代码以返回链上的值，那就很理想了。如果没有，如果您可以累积一组单独的返回值，并在处理完成后合并它们，通常也很好。如果两者都不可行，则需要用锁保护所有对

结果的访问。有关详细信息，请参阅

最后，您需要询问将并行性放在何处。关键是在独立任务之间找到正确的分界线

理想情况下，您希望找到大量可以排队的中型作业，并且只需要有一个进程池，每个进程都可以选择下一个。快速看一眼，最明显的地方是递归调用
self.pack
，或者每次迭代
for i in items:
循环。如果它们实际上是独立的，那么只需使用，如中所示。（如果您使用的是Python 3.1或更早版本，则需要该模块，因为它没有内置到stdlib中。）

如果没有简单的方法可以做到这一点，通常至少可以创建少量（N个或2N个，如果您有N个核）大小大致相同的长期运行作业，然后只给每个作业分配自己的作业。例如：

def run(self, items, i, n, current):
    global num_threads, thread_started
    lock.acquire()
    num_threads += 1
    thread_started = True
    lock.release()
    if current[1] + i[1] <= self.B and i[0] not in current[0]:
        i = (current[0] + " " + i[0], current[1] + i[1], current[2] + i[2])
        self.pack(items, n, i)
    else:
        if current[2] > results[0][2]:
            results[0] = current
    lock.acquire()
    num_threads -= 1
    lock.release() 

最后一点注意：如果你完成了你的代码，并且看起来你已经通过隐式共享全局文件逃脱了惩罚，那么你实际上所做的是编写的代码，这些代码通常但并不总是在某些平台上工作，而从来没有在其他平台上工作过。请参阅
多处理
文档的一节，了解应避免的问题，如果可能，请定期在Windows上进行测试，因为Windows是限制性最强的平台


你还要问第二个问题：

你能告诉我第二个密码有什么问题吗

现在还不完全清楚您在这里试图做什么，但是有一些明显的问题（除了上面提到的）


在您向我们展示的代码中，您没有在任何地方创建线程。仅仅创建名称中带有“thread”的变量并不能提供并行性。如果你没有任何线程，那么所有的锁所能做的就是无缘无故地降低你的速度
根据您的描述，听起来好像您试图使用
线程
模块，而不是
线程
。有一个原因是
线程
文档的顶部告诉您不要使用它，而是使用
线程
你有一个锁来保护你的线程数（这根本不需要），但是没有锁来保护你的
结果。在Python中的大多数情况下，您都可以避免这种情况（由于上面提到的同一个GIL问题，您的线程基本上不会并发运行，因此它们不会有争用），但这仍然是一个非常糟糕的主意（特别是如果您不确切了解那些“大多数情况”是什么的话）


但是，您的
run
函数似乎是基于
for i in items:
loop in
pack
的主体的。如果这是一个并行化的好地方，那么你就很幸运了，因为从循环的每次迭代中创建一个并行任务正是
futures
和
multiprocessing
最擅长的。例如，此代码：

n = 8
procs = [Process(target=rucksack.pack, args=(items[i//n:(i+1)//n],)) for i in range(n)]

…当然可以写成：

results = []
for i in items:
    result = dostuff(i)
    results.append(result)

它可以简单地并行化，甚至不需要了解未来是什么，例如：

results = map(dostuff, items)

在Python中用线程并行化CPU绑定的任务是毫无意义的，因为。首先，您实际使用的是
thread
模块吗？如果是这样，请不要使用
线程
，正如最上面的命令所示。但是，更重要的是，这里没有创建任何线程。只是在单线程代码中添加锁而已
pool = concurrent.futures.ProcessPoolExecutor()
results = pool.map(dostuff, items)