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

时间：2024-10-09 21:36:09

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

 

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中函数也是对象）。

 

完。

相关文章