如何在Python2.7中进行并行合并排序？

我曾尝试在Python2.7中并行合并排序，但做不到。因为我不知道应该用线程还是多处理实现。请在线程中编写并行代码或多处理这些代码：

def merge(left, right):
result = []
i ,j = 0, 0
while i < len(left) and j < len(right):
    print('left[i]: {} right[j]: {}'.format(left[i],right[j]))
    if left[i] <= right[j]:
        print('Appending {} to the result'.format(left[i]))           
        result.append(left[i])
        print('result now is {}'.format(result))
        i += 1
        print('i now is {}'.format(i))
    else:
        print('Appending {} to the result'.format(right[j]))
        result.append(right[j])
        print('result now is {}'.format(result))
        j += 1
        print('j now is {}'.format(j))
print('One of the list is exhausted. Adding the rest of one of the lists.')
result += left[i:]
result += right[j:]
print('result now is {}'.format(result))
return result

def mergesort(L):
print('---')
print('mergesort on {}'.format(L))
if len(L) < 2:
    print('length is 1: returning the list withouth changing')
    return L
middle = len(L) / 2
print('calling mergesort on {}'.format(L[:middle]))
left = mergesort(L[:middle])
print('calling mergesort on {}'.format(L[middle:]))
right = mergesort(L[middle:])
print('Merging left: {} and right: {}'.format(left,right))
out = merge(left, right)
print('exiting mergesort on {}'.format(L))
print('#---')
return out

mergesort([6,5,4,3,2,1])

def合并（左、右）：
结果=[]
i，j=0，0
而i如果左[i]在这种情况下，我会说线程和多处理都不一定会加快速度

在CPython中，全局解释器锁（“GIL”）确保一次只有一个线程在执行Python字节码。除其他外，这样做是为了使内存管理更容易。因此，假设要排序的数据在内存中，线程不会加快排序速度，因为一次只有一个线程在处理它

除非您对数据使用共享内存，如
多处理.Array
，否则多处理需要对数据进行pickle处理并将其发送给子进程，以便它们处理数据。子进程也会执行相同的操作将其发送回。数据集越大，产生的开销就越大。而
数组
使用锁定来序列化访问。这是一件好事，但它会让你慢下来。您可以使用不使用锁定的
RawArray
，但在修改数据时必须非常小心

我能想到的最好的方法是如下。在这种情况下，可以排序的数据仅限于
多处理.SharedTypes.RawArray
接受的数据


创建两个
多处理.SharedTypes.RawArray
实例A和B。数组A包含未排序的数据，数组B（大小与B相同）的所有值都设置为0
如果您的CPU有N个内核，则创建一个包含N个工作进程的
多处理.Pool
（这是默认值）。然后创建一个元组序列，将数组的索引划分为N个连续部分。假设您有一个包含16个值的数组，且N=4。那么该序列将是
（（0,3）、（4,7）、（8,11）、（12,15））
然后调用给定序列上的
Pool.map
方法。然后，每个工作进程都会收到一个元组，指示它应该使用的共享数组的哪一部分
每个工作人员读取其负责的A列表部分，对数据进行排序，并将排序后的数据写入B列表的同一部分
最后，父进程将B数组的四个部分按正确顺序排列
在这种情况下，我想说的是，线程和多处理都不一定会加快速度

在CPython中，全局解释器锁（“GIL”）确保一次只有一个线程在执行Python字节码。这样做是为了更容易地管理内存。因此，假设要排序的数据在内存中，线程不会加快执行速度，因为一次只有一个线程在处理它

除非您对数据使用共享内存（如
多处理.Array
），否则多处理需要对数据进行pickle处理并将其发送给子进程，以便它们处理数据。子进程也会执行同样的操作将数据发送回。数据集越大，产生的开销就越大。而
数组
使用锁定来序列化访问这是一件好事，但它会减慢速度。您可以使用不使用锁定的
RawArray
，但在修改数据时必须非常小心

我能想到的最好的方法是以下方法。在这种情况下，您可以排序的数据仅限于
多处理.sharedTypes.RawArray
接受的数据


创建两个
多处理.SharedTypes.RawArray
实例A和B。数组A包含未排序的数据，数组B（大小与B相同）的所有值都设置为0
如果您的CPU有N个内核，则创建一个包含N个工作进程的
多处理.Pool
（这是默认值）。然后创建一个元组序列，将数组的索引划分为N个连续部分。假设您有一个包含16个值的数组，且N=4。那么该序列将是
（（0,3）、（4,7）、（8,11）、（12,15））
然后调用给定序列上的
Pool.map
方法。然后，每个工作进程都会收到一个元组，指示它应该使用的共享数组的哪一部分
每个工作人员读取其负责的A列表部分，对数据进行排序，并将排序后的数据写入B列表的同一部分
最后，父进程将B数组的四个部分按正确顺序排列
你知道这些代码都不会运行，对吧？要么是你从某个随机的地方复制并粘贴了它，要么就是你把格式搞砸了“请在线程中编写并行代码，或者多处理这些代码”这是命令吗？@TigerhawkT3我正要问同样的问题：）@TigerhawkT3不是命令亲爱的用户。这只是帮助，但如果你可以的话！你知道这些代码都不会运行，对吧？要么是你从某个随机的地方复制并粘贴了它，要么就是你把格式搞砸了“请在线程中编写并行代码或多处理这些代码”这是命令吗？@TigerhawkT3我正要问同样的问题：）@TigerhawkT3，不是一个订单亲爱的用户。它只是帮助，但如果你可以！