Python学习笔记（三）多线程的使用

这节记录学习多线程的心得。

 

Python提供了thread模块，不过该模块的缺点很多，例如无法方便的等待线程结束，所以我们使用更加高级的threading模块。

 

threading模块的使用一共三种模式：

1.利用函数生成一个Thread实例

2.利用函数生成一个可以调用的类对象，生成一个Thread实例

3.从Thread派生一个子类，创建这个子类的实例

 

利用函数生成Thread实例

 

第一种使用方式最为简单，代码如下：

import threading
from time import sleep

def threadFunc():
    i = 10;
    while i > 0:
        print 'i = %d' % i
        i -= 1

if __name__ == '__main__':
    t = threading.Thread(target = threadFunc)
    t.start()
    t.join()

这段代码的逻辑很简单，就是在线程中执行threadFunc这个函数。

如果该函数需要参数的话，在

t = threading.Thread(target = threadFunc)

这一行添加一个参数即可，如下：

import threading
from time import sleep

def threadFunc(i):
    while i > 0:
        print 'i = %d' % i
        i -= 1

if __name__ == '__main__':
    t = threading.Thread(target = threadFunc, args = [10])
    t.start()
    t.join()

注意args参数必须使用元组或者列表。

 

利用函数生成一个可以调用的类对象，生成一个Thread实例

 

我们先补充一些知识，C++中有函数对象，就是对某一个类重载函数调用操作符，那么该类的对象就可以当做函数来使用，python中也有同样的机制：

class Foo():
    def __call__(self):
        print 'foobar'

if __name__ == '__main__':
    f = Foo()
    f()

此例中f是一个对象，但可以当做函数使用。当调用f()时，解释器调用了Foo中的__call__方法，相当于C++中的operator()操作符被重载。

 

还有一个关于apply的知识点：

def test(i):
    print 'i = %d' % i 

if __name__ == '__main__':
    apply(test, [1])

apply可以这样调用函数。通过这种机制，我们可以将函数存储起来，选择合适的时机注意调用。

from random import randint

def foo(i):
    print 'i = %d' % i
def bar(i):
    print 'i*i = %d' % (i*i)

class Foo():
    def __call__(self, i):
        print 'foobar: %d' % i

if __name__ == '__main__':
    funcs = [foo, bar, Foo()]
    for func in funcs:
        i = randint(1, 4)
        apply(func, [i])

 

于是我们可以将函数存储在类中，为该类提供__call__函数，此时这个类的对象也是可以执行的，所以我们利用这个对象去生成Thread。

#coding: utf-8
import threading
from time import sleep

class ThreadFunc(object):
    def __init__(self, func, args):
        self.func = func
        self.args = args

    def __call__(self):
        apply(self.func, self.args)

def loop(i):
    while i > 0:
        print 'i = %d' % i
        sleep(0.5)
        i -= 1

if __name__ == '__main__':
    print '在主线程内执行这个函数'
    t1 = ThreadFunc(loop, [5])
    t1()

    print '开始执行一个新的线程'
    t2 = threading.Thread(target = t1)
    t2.start()
    t2.join()
    print '线程执行完毕'

    print '开始执行一个新的线程'
    t3 = threading.Thread(target = ThreadFunc(loop, [3]))
    t3.start()
    t3.join()
    print '线程执行完毕'

t1是个ThreadFunc的实例，既可以直接执行，又可以使用它去生成Thread实例。

 

从Thread派生一个子类，创建这个子类的实例

 

最简单的使用方式如下：

import threading
from time import sleep

class MyThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.count = 10

    def run(self):
        while self.count > 0:
            print 'i = %d' % self.count
            sleep(1)
            self.count -= 1

if __name__ == '__main__':
    t = MyThread();
    t.start()
    t.join()

我们去继承Thread类，然后覆盖其中的run方法，这与Java的Thread使用相一致。

创建多个线程可以这样：

import threading
from time import sleep

class MyThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        print 'begin .....'
        sleep(5)
        print 'end.....'

if __name__ == '__main__':
    threads = []
    for i in range(10):
        t = MyThread()
        threads.append(t)
    for t in threads:
        t.start()
    for t in threads:
        t.join()

 

不过，目前我们的线程逻辑是固定的，可以借鉴第二种方式，从外部传入逻辑，存储起来。

#coding: utf-8
import threading
from time import sleep

class CustomThread(threading.Thread):
    def __init__(self, func, args):
        threading.Thread.__init__(self)
        self.func = func
        self.args = args

    def run(self):
        apply(self.func, self.args)

def loop(i):
    while i > 0:
        print 'i = %d' % i
        sleep(0.5)
        i -= 1

if __name__ == '__main__':
    t = CustomThread(loop, [10])
    t.start()
    t.join()

这里跟第二种不同的是：

1.采用了继承，基类是Thread

2.覆盖run方法，而不是提供__call__方法

3.使用时直接创建该类的实例

以上三种，我个人感觉第三种最方便，在大一些程序中，可以将该Thread单独做成一个模块。

另外，前两种的本质是一样的，都是向Thread传入一个可以执行的对象（python中函数也是对象）。

 

完。