Question

python 多进程读取同一个循环处理、可以用multiprocessing

比如我有一个循环，需要取出每一项处理，处理很耗时间，所以我想多进程处理，每一个进程迭代读取该循环后分开处理，最后结果整合到一起。
如：
我循环里面有100行数据，5个进程的话，就是每个进程20行数据。

def testFunc(f,l):
l.acquire()
for i in f:
(head,seq,temp,score) = i
l.release()
###########function###########

l.acquire()
l.release()

lock = Lock()
for i in range(5):
t = Process(target = testFunc, args=(f,lock))
t.start()
threads.append(t)

for j in range(len(threads)):
threads[j].join()

但是实现后大发现每个进程读取的数据都是所有的100行数据，而不是迭代的读取，每一个进程20行数据。求大侠知道。
args=(f,lock)

变量f是一个打开文本的句柄。

Answer 1

可以每个在func中加上一个参数data,data是这个线程处理的数据；

多线程处理的时候，给每个线程分配相应的data就可以了。

给个示例：

# -*- coding:utf-8 -*-
import thread,threading
import time

def FuncTest(tdata):
    print tdata
    
class mythread(threading.Thread):
    def __init__(self,threadname):
        threading.Thread.__init__(self)

    def run(self):
        lock.acquire()
        FuncTest(ft)
        lock.release()
        
def MutiThread(num):
    threads=[]
    i=0
    global ft
    for x in xrange(num):
        threads.append(mythread(num))
    for t in threads:
        time.sleep(0.5)
        lock.acquire()
        ft=GetThreadParam(datafile,num,i)
        #print '[%s]Thread:%s,Testdata:%s'%(time.ctime(),t,ft)
        i=i+1
        t.start() 
        lock.release()
    for t in threads:
        t.join()

def GetThreadParam(datafile, num, curthread):
    #线程数需要小于文件行数
    f=open(datafile,'r')
    lines=f.readlines()
    divres=divmod(len(lines),num)
    if curthread<(num-1):
        res=lines[curthread*divres[0]:(curthread+1)*divres[0]]
    elif curthread==(num-1):
        res=lines[curthread*divres[0]:((curthread+1)*divres[0]+divres[1])]
    return res
    f.close()
    
if __name__ == '__main__':
    
    global num,lock
    datafile='a.txt'
    
    num=3  #num 并发数
    
    lock=threading.Lock()
    MutiThread(num)

a.txt文件内容如下

1

2

3

4

5

6

7

8

9

10

3个线程并发时，运行结果：

>>> 

['1\n', '2\n', '3\n']

['4\n', '5\n', '6\n']

['7\n', '8\n', '9\n', '10']