Question

在下面的代码中需要一些帮助，它必须有一些问题，因为顺序排序比使用并行版本得到更好的结果。我是python的新手，尤其是并行编程，欢迎任何帮助。

import random, time
from multiprocessing import Process, Pipe,cpu_count
from copy import deepcopy


def main():
    create_list = [random.randint(1,1000) for x in range(25000)]



    #sequential sort
    sequentialsortlist=deepcopy(create_list)


    start = time.time()
    sorted2 =quicksort(sequentialsortlist)
    elapsed = time.time() - start
    print("sequential sort")
    print(elapsed)




    time.sleep(4)

    #Parallel quicksort.
    parallelsortlist = deepcopy(create_list)

    start = time.time()
    n = cpu_count()

    pconn, cconn = Pipe()


    p = Process(target=quicksortParallel,
                args=(parallelsortlist, cconn, n,))
    p.start()

    lyst = pconn.recv()


    p.join()

    elapsed = time.time() - start
    print("Parallels sort")
    print(elapsed)


def quicksort(lyst):

    less = []
    pivotList = []
    more = []
    if len(lyst) <= 1:
        return lyst
    else:
        pivot = lyst[0]
        for i in lyst:
            if i < pivot:
                less.append(i)
            elif i > pivot:
                more.append(i)
            else:
                pivotList.append(i)
        less = quicksort(less)
        more = quicksort(more)
        return less + pivotList + more

def quicksortParallel(lyst, conn, procNum):


   less = []
   pivotList = []
   more = []

   if procNum <= 0 or len(lyst) <= 1:
       conn.send(quicksort(lyst))
       conn.close()
       return
   else:
       pivot = lyst[0]
       for i in lyst:
           if i < pivot:
               less.append(i)
           elif i > pivot:
               more.append(i)
           else:
               pivotList.append(i)


   pconnLeft, cconnLeft = Pipe()

   leftProc = Process(target=quicksortParallel,
                      args=(less, cconnLeft, procNum - 1))


   pconnRight, cconnRight = Pipe()
   rightProc = Process(target=quicksortParallel,
                      args=(more, cconnRight, procNum - 1))


   leftProc.start()
   rightProc.start()


   conn.send(pconnLeft.recv()+pivotList + pconnRight.recv())
   conn.close()

   leftProc.join()
   rightProc.join()


if __name__ == '__main__':
    main()

Answer 1

简单的答案是，设置并行执行环境然后在最后重新加入它的开销比从并行性中获得的性能提升要贵。

多处理实际上分叉子流程。这非常昂贵。如果每个线程中完成的工作量非常大，那么这样做才有意义。

当人们狡猾地尝试并行化代码时，这种问题实际上很常见。对于许多合理的人而言，这很常见。工作负载单线程实现的速度越来越快。

Python快速排序并行排序比顺序慢

1 个答案: