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

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

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

给个示例：

# -- coding:utf-8 --

import thread,threading

import time

def FuncTest(tdata):

    print tdata

    

class mythread(threadingThread):

    def __init__(self,threadname):

        threadingThread__init__(self)

    def run(self):

        lockacquire()

        FuncTest(ft)

        lockrelease()

        

def MutiThread(num):

    threads=[]

    i=0

    global ft

    for x in xrange(num):

        threadsappend(mythread(num))

    for t in threads:

        timesleep(05)

        lockacquire()

        ft=GetThreadParam(datafile,num,i)

        #print '[%s]Thread:%s,Testdata:%s'%(timectime(),t,ft)

        i=i+1

        tstart() 

        lockrelease()

    for t in threads:

        tjoin()

def GetThreadParam(datafile, num, curthread):

    #线程数需要小于文件行数

    f=open(datafile,'r')

    lines=freadlines()

    divres=divmod(len(lines),num)

    if curthread<(num-1):

        res=lines[curthreaddivres[0]:(curthread+1)divres[0]]

    elif curthread==(num-1):

        res=lines[curthreaddivres[0]:((curthread+1)divres[0]+divres[1])]

    return res

    fclose()

    

if __name__ == '__main__':

    

    global num,lock

    datafile='atxt'

    

    num=3  #num 并发数

    

    lock=threadingLock()

    MutiThread(num)

atxt文件内容如下

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']

多线程/多进程都是通讯或者回调，而不是直接返回结果。这个很容易理解的，因为如果你用返回结果来给一个变量赋值，你就必须等待这个函数结束，你这个程序就阻塞了，这就失去了多线程/多进程防止阻塞的意义了。

通讯可以是事件驱动或者用线程安全的数据结构来传递数据（比如Queue，也可以是消息队列0mq，rabbitMQ之类），回调就是你一个程序执行完成后调用另外一个函数来处理接下来怎么做。

到这里，我们要聊一下线程通信的内容；

首先，我们抛开语言不谈，先看看比较基础的东西，线程间通信的方式；其实也就是哪几种（我这里说的，是我的所谓的知道的。。。）事件，消息队列，信号量，条件变量（锁算不算？我只是认为是同步的一种）；所以我们也就是要把这些掌握了，因为各有各的好处嘛；

条件变量我放到了上面的线程同步里面讲了，我总感觉这算是同步的一种，没有很多具体信息的沟通；同时吧，我认为条件变量比较重要，因为这种可以应用于线程池的 *** 作上；所以比较重要；这里，抛开条件变量不谈，我们看看其他的东西；

1、消息队列：

queue 模块下提供了几个阻塞队列，这些队列主要用于实现线程通信。在 queue 模块下主要提供了三个类，分别代表三种队列，它们的主要区别就在于进队列、出队列的不同。

关于这三个队列类的简单介绍如下：

queueQueue(maxsize=0)：代表 FIFO（先进先出）的常规队列，maxsize 可以限制队列的大小。如果队列的大小达到队列的上限，就会加锁，再次加入元素时就会被阻塞，直到队列中的元素被消费。如果将 maxsize 设置为 0 或负数，则该队列的大小就是无限制的。

queueLifoQueue(maxsize=0)：代表 LIFO（后进先出）的队列，与 Queue 的区别就是出队列的顺序不同。

PriorityQueue(maxsize=0)：代表优先级队列，优先级最小的元素先出队列。

这三个队列类的属性和方法基本相同， 它们都提供了如下属性和方法：

Queueqsize()：返回队列的实际大小，也就是该队列中包含几个元素。

Queueempty()：判断队列是否为空。

Queuefull()：判断队列是否已满。

Queueput(item, block=True, timeout=None)：向队列中放入元素。如果队列己满，且 block 参数为 True（阻塞），当前线程被阻塞，timeout 指定阻塞时间，如果将 timeout 设置为 None，则代表一直阻塞，直到该队列的元素被消费；如果队列己满，且 block 参数为 False（不阻塞），则直接引发 queueFULL 异常。

Queueput_nowait(item)：向队列中放入元素，不阻塞。相当于在上一个方法中将 block 参数设置为 False。

Queueget(item, block=True, timeout=None)：从队列中取出元素（消费元素）。如果队列已满，且 block 参数为 True（阻塞），当前线程被阻塞，timeout 指定阻塞时间，如果将 timeout 设置为 None，则代表一直阻塞，直到有元素被放入队列中； 如果队列己空，且 block 参数为 False（不阻塞），则直接引发 queueEMPTY 异常。

Queueget_nowait(item)：从队列中取出元素，不阻塞。相当于在上一个方法中将 block 参数设置为 False。

其实我们想想，这个队列，是python进行封装的，那么我们可以用在线程间的通信；同时也是可以用做一个数据结构；先进先出就是队列，后进先出就是栈；我们用这个栈写个十进制转二进制的例子：

没毛病，可以正常的打印；其中需要注意的就是，maxsize在初始化的时候如果是0或者是个负数的话，那么就会是不限制大小；

那么其实我们想想，我们如果用做线程通信的话，我们两个线程，可以把队列设置为1的大小，如果是1对多，比如是创建者和消费者的关系，我们完全可以作为消息队列，比如说创建者一直在创建一些东西，然后放入到消息队列里面，然后供消费着使用；就是一个很好的例子；所以，其实说是消息队列，也就是队列，没差；

=====================================================================

下面来看一下事件

Event 是一种非常简单的线程通信机制，一个线程发出一个 Event，另一个线程可通过该 Event 被触发。

Event 本身管理一个内部旗标，程序可以通过 Event 的 set() 方法将该旗标设置为 True，也可以调用 clear() 方法将该旗标设置为 False。程序可以调用 wait() 方法来阻塞当前线程，直到 Event 的内部旗标被设置为 True。

Event 提供了如下方法：

is_set()：该方法返回 Event 的内部旗标是否为True。

set()：该方法将会把 Event 的内部旗标设置为 True，并唤醒所有处于等待状态的线程。

clear()：该方法将 Event 的内部旗标设置为 False，通常接下来会调用 wait() 方法来阻塞当前线程。

wait(timeout=None)：该方法会阻塞当前线程。

这里我想解释一下；其实对于事件来说，事件可以看成和条件变量是一样的，只是我们说说不一样的地方；

1、对于事件来说，一旦触发了事件，也就是说，一旦set为true了，那么就会一直为true，需要clear调内部的标志，才能继续wait；但是conditon不是，他是一次性的唤醒其他线程；

2、conditon自己带锁；事件呢？不是的；没有自己的锁；比如说有一个存钱的线程，有一个是取钱的线程；那么存钱的线程要存钱；需要怎么办呢？1、发现银行没有钱了（is_set判断）；2、锁住银行；3、存钱；4、释放银行；5、唤醒事件；对于取钱的人；1、判断是否有钱；2、被唤醒了，然后锁住银行；3、开始取钱；4、清理告诉存钱的人，我没钱了（clear）；5、释放锁；6、等着钱存进去；

其实说白了，就是记住一点；这个旗标需要自己clear就对了

写个例子，怕以后忘了怎么用；

其实时间和信号量比较像；但是信号量不用自己清除标志位；但是事件是需要的；

以上就是关于python 多进程读取同一个循环处理、可以用multiprocessing全部的内容，包括:python 多进程读取同一个循环处理、可以用multiprocessing、python threading模块，生成多线程之后，怎么得到线程执行完成后return出的字符串呢、python基础（21）-线程通信等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！