python多线程（2）--thread和threading模块的使用

thread模块
python不推荐使用这个模块，推荐更高级的threading。
thread模块和对象

函数	描述
start_new_thread(function,args)	产生新线程，指定函数和参数
allocate_lock()	分配一个LockType类型的锁对象
exit()	线程退出
LockType对象的方法
acquire()	尝试获取对象对象
locked	如果获取了返回True否则返回False
release()	释放锁

thread.py

#coding:utf-8
import thread
from time import sleep,ctime
loops=[4,2]#睡眠时间

def loop(nloop,nsec,lock):
    print 'start loop',nloop,'at:',ctime()
    sleep(nsec)
    print 'loop',nloop,'done at:',ctime()
    lock.release()#释放锁对象

def main():
    print 'starting at :',ctime()
    locks=[]
    nloops=range(len(loops))#创建nloops数组

    #创建锁并加入组
    for i in nloops:
        lock=thread.allocate_lock()#创建 lock （不能直接加入）
        lock.acquire()#尝试获取lock
        locks.append(lock)#加入组

    for i in nloops:
        thread.start_new_thread(loop,(i,loops[i],locks[i]))#创建线程
    #获取锁对象 成功True 失败False
    for i in nloops:
        while locks[i].locked():pass#如果锁对象被释放 表示解锁了 可以继续执行

    print 'all DONE at:',ctime()

if __name__ == '__main__':
    main()

输出:

starting at : Tue Jul 19 20:23:29 2016
start loop start loop0  1at:  at:Tue Jul 19 20:23:29 2016 
Tue Jul 19 20:23:29 2016
loop 1 done at: Tue Jul 19 20:23:31 2016
loop 0 done at: Tue Jul 19 20:23:33 2016
all DONE at: Tue Jul 19 20:23:33 2016

Threading模块
提供除了thread以及其他同步机制，主要是thread类
Threading模块下的thread类的使用:

函数	描述
run()	通常需要重写，编写代码实现 做需要的功能。定义线程功能的函数
getName()	获得线程对象名称
setName()	设置线程对象名称
start()	启动线程
jion([timeout])	等待另 一线程结束后再运行。timeout设置等待时间。
setDaemon(bool)	设置子线程是否随主线程一起结束，必须在start()之前调用。默认为False。
isDaemon()	判断线程是否随主 线程一起结束。
isAlive()	检查线程是否在运行中。

threading下的thread类的使用.py

#coding:utf-8
import threading
from time import sleep,ctime
loops=[4,2]

def loop(nloop,nsec):
    print 'start loop',nloop,'at:',ctime()
    sleep(nsec)
    print 'loop',nloop,'done at:',ctime()

def main():
    print 'starting at:',ctime()
    threads=[]
    nloops=range(len(loops))

    for i in nloops:#创建但不开始执行线程
        t=threading.Thread(target=loop,args=(i,loops[i]))
        threads.append(t)
    for i in nloops:#开始
        threads[i].start()
    for i in nloops:#让主线程等待
        threads[i].join()
    print 'all DONE at:',ctime()

if __name__ == '__main__':
    main()

输出:

starting at: Wed Jul 20 08:47:15 2016
start loop 0 at: Wed Jul 20 08:47:15 2016
start loop 1 at: Wed Jul 20 08:47:15 2016
loop 1 done at: Wed Jul 20 08:47:17 2016
loop 0 done at: Wed Jul 20 08:47:19 2016
all DONE at: Wed Jul 20 08:47:19 2016

重写threading下的thread类:
1.先调用基类的构造器
2.重写run()方法-(前面_call_())-。

#MyThread.py
#coding:utf-8
import threading
from time import ctime
class MyThread(threading.Thread):
    #类继承
    '''
    def __int__(self,func,args,name=''):
        #构造函数
        threading.Thread.__init__(self)
        self.name=name
        self.func=func
        self.args=args'''
    def __init__(self,func,args,name=''):
       threading.Thread.__init__(self)
       self.name = name
       self.func = func
       self.args = args

    def getResult(self):
        return self.res

    def run(self):
        print 'starting',self.name,'at:',ctime()
        self.res=apply(self.func,self.args)#运行函数 传人函数和参数
        print self.name,'finished at:',ctime()

坑:是__init__不是__int__

使用自定义类:

# -*- coding:utf-8 -*-
from myThread import MyThread
from time import ctime, sleep
def fib(x):
    """求斐波那契数列之和"""
    sleep(0.005)
    if x < 2:
        return 1
    return fib(x-2) + fib(x-1)
def fac(x):
    """求阶乘"""
    sleep(0.1)
    if x < 2:
        return 1
    return x * fac(x-1)
def sum_(x):
    """自然数累加和"""
    sleep(0.1)
    if x < 2:
        return 1
    return x + sum_(x-1)

funcs = [fib, fac, sum_]  # 将三个函数放到列表中
n = 12
def main():
    nfuncs = range(len(funcs))  # nfuncs = range(3)

    print '*** SINGLE THREAD'  # 单线程计算三个函数
    for i in nfuncs:
        print 'staring', funcs[i].__name__, 'at:', ctime()  # 打印出函数名称，开始运行时间
        print funcs[i](n)  # 打印计算结果
        print funcs[i].__name__, 'finished at:', ctime()  # 打印出函数名称，结束运行时间

    print '\n*** MULTIPLE THREADS'  # 多线程计算三个函数
    threads = []
    for i in nfuncs:
        t = MyThread(funcs[i], (n,), funcs[i].__name__)  # 实例化三个MyThread对象
        threads.append(t)  # 将三个对象放到列表中

    for i in nfuncs:
        threads[i].start()  # 启动三个线程

    for i in nfuncs:
        threads[i].join()  # join()会等到线程结束或超时，即允许主线程等待线程结束
        print threads[i].getResult()  # 调用对象的getResult()方法

    print 'all DONE'

if __name__ == '__main__':  # 独立运行脚本，即在此脚本在直接运行时，才会调用main()函数
    main()

输出：

*** SINGLE THREAD
staring fib at: Wed Jul 20 10:57:21 2016
233
fib finished at: Wed Jul 20 10:57:23 2016
staring fac at: Wed Jul 20 10:57:23 2016
479001600
fac finished at: Wed Jul 20 10:57:24 2016
staring sum_ at: Wed Jul 20 10:57:24 2016
78
sum_ finished at: Wed Jul 20 10:57:25 2016

*** MULTIPLE THREADS
starting fib at: Wed Jul 20 10:57:25 2016
starting fac at: Wed Jul 20 10:57:25 2016
starting sum_ at: Wed Jul 20 10:57:25 2016
sum_ finished at: Wed Jul 20 10:57:27 2016
fac finished at: Wed Jul 20 10:57:27 2016
fib finished at: Wed Jul 20 10:57:28 2016
233
479001600
78

单线程一个一个执行，多线程一起执行，节省时间。