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

可以每个在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']

如果有个很大的文件，几十G?，需要每次读取一部分，处理后再读取剩余部分。

with open as f 已经从内部处理难点，使用 for line in f 以迭代器的形式每次读取一行，不会有内存问题。

下面程序的思路是用一个列表存放读取到的数据，达到长度后就开始处理，处理完就清空列表，继续执行

---