更新

Question

3sum问题定义为给定：正整数k≤20，正整数n≤104和k数组n包含从−105到105的整数。< / p>

返回：For each array A[1..n]，输出三个不同的索引1≤p<q<r≤n，如果存在则A[p]+A[q]+A[r]=0，否则"-1"。

Sample Dataset
4 5
2 -3 4 10 5
8 -6 4 -2 -8
-5 2 3 2 -4
2 4 -5 6 8

Sample Output
-1
1 2 4
1 2 3
-1

但是我想使用线程加速代码，为此我正在应用python代码

def TS(arr):
    original = arr[:]
    arr.sort()
    n = len(arr)        
    for i in xrange(n-2):
        a = arr[i]
        j = i+1
        k = n-1
        while j < k:
            b = arr[j]
            c = arr[k]
            if a + b + c == 0:
                return sorted([original.index(a)+1,original.index(b)+1,original.index(c)+1])
            elif a + b + c > 0:
                k = k - 1
            else:
                j = j +1
    return [-1]

with open("dataset.txt") as dataset:
   k = int(dataset.readline().split()[0]) 
   for i in xrange(k):
       aux = map(int, dataset.readline().split())
       results = TS(aux)
       print ' ' . join(map(str, results))

我在考虑创建k个线程和全局数组输出，但是不知道如何继续开发这个想法

from threading import Thread

class thread_it(Thread):
    def __init__ (self,param):
        Thread.__init__(self)
        self.param = param
    def run(self):
        mutex.acquire()
        output.append(TS(aux))
        mutex.release() 


threads = []  #k threads
output = []   #global answer
mutex = thread.allocate_lock()
with open("dataset.txt") as dataset:
       k = int(dataset.readline().split()[0]) 
       for i in xrange(k):
           aux = map(int, dataset.readline().split())           
           current = thread_it(aux)
           threads.append(current)
           current.start()

       for t in threads:
           t.join()

在线程中获取results = TS(aux)然后等待所有线程完成然后print ' ' . join(map(str,results))为所有线程的正确方法是什么？

更新

从控制台运行脚本时出现此问题

Answer 1

首先，就像@Cyphase所说，由于GIL，你无法用threading加快速度。每个线程都将在同一个核心上运行。考虑使用multiprocessing来使用多个核心，multiprocessing具有与线程非常相似的API。

其次，即使我们假装GIL不存在。将所有内容放在受mutex保护的关键部分中，您实际上是在序列化所有线程。您需要保护的是访问output，因此请将处理代码放在关键部分之外，以使它们同时运行：

def run(self):
    result = TS(aux)
    mutex.acquire()
    output.append(result)
    mutex.release()

但是不要重新发明轮子，python标准库提供了一个线程安全的队列，使用它：

try:
    import Queue as queue  # python2
except:
    import queue
output = queue.Queue()

def run(self):
    result = TS(self.param)
    output.append(result)

使用多处理，最终代码如下所示：

from multiprocessing import Process, Queue
output = Queue()

class TSProcess(Process):
    def __init__ (self, param):
        Process.__init__(self)
        self.param = param
    def run(self):
        result = TS(self.param)
        output.put(result)

processes = []  
with open("dataset.txt") as dataset:
       k = int(dataset.readline().split()[0]) 
       for i in xrange(k):
           aux = map(int, dataset.readline().split())           
           current = TSProcess(aux)
           processes.append(current)
           current.start()

       for p in processes:
           p.join()
       # process result with output.get()

使用k个线程完成多线程并行化过程

更新

1 个答案: