python多线程模块thread

阳光穿透心脏的1/2处 2022-06-15 07:07 476阅读 0赞

#### thread介绍 ####

python提供多线程模块thread及threading，以及队列Queue，其中thread相对比较基础，不容易控制，但并不是说明无用，有些老司机偶尔会使用thead参看底层堆栈内存，官方建议使用threading模块，thread模块在python3版本中被重命名为\_thread

Python解释器中可以同时运行多个线程，但是在任意时刻只能有一个线程在解释器运行。  
Python虚拟机的访问是由全局解锁器（GIL）控制的，由GIL保证同时只有一个线程的运行。  
执行方式如下：  
设置GIL  
切换到一个进程进行执行  
执行下面操作中的一个  
　　1.运行指定数量的字节码  
　　2.线程主动出让控制权  
将线程设置为睡眠状态，即切换出线程，比如使用sleep(0)  
解锁GIL  
loop

#### thread提供以下函数方法： ####

1.exception thread.error 异常

2.thread.LockType 锁类型

3.thread.start\_new\_thread(function, args\[, kwargs\]) 开始一个线程，function函数名称，以及args参数是必须的，如果函数本身没有传参，  
则ye需要给args传入一个参数，例如（）空列表就可以了，但传入参数时，需要在后面添加上逗号(,)，例如thread.start\_new\_thread(hello, (“tom”,))

4.thread.interrupt\_main() 终端main进程

5.thread.exit() 线程退出

6.thread.allocate\_lock() 设置锁

7.thread.get\_ident() 获取当前线程的标识符，是一个非零的整数

8.thread.stack\_size(\[size\]) 内存堆栈的大小，可以是0或大于32Kb的整数，如果大小无效则会抛出异常

注：

1.退出的方法 sys.exit() 或抛出 SystemExit异常  
2.当主程序退出时，不论子线程是否执行完成，都会结束，没有线程守护

#### thread提供锁机制： ####

1.lock.acquire(\[waitflag\]) 请求锁，waitflag是请求超时时间，如果为0，则表示立即能获得的，若为非零整数，则等待超时时间内获取

2.lock.release() 锁释放

3.lock.locked() 锁的状态

4.thread.allocate\_lock() 加载锁

示例如下：  
创建两个普通的函数，读书，听音乐

#coding=utf8
    
    from time import ctime,sleep
    
    def readbook(name="time"):
        print "%s reading book : %s"%(ctime(),name)
        sleep(2)
        print "%s end read book"%(ctime())
    
    def listenmusic(name="好汉歌"):
        print "%s listening music : %s"%(ctime(),name)
        sleep(5)
        print "%s play music " % (ctime())
    
    print "start--- %s"%(ctime())
    readbook()
    listenmusic()
    print "end --- %s"%(ctime())

输出如下：

start--- Fri May 26 20:13:52 2017
    Fri May 26 20:13:52 2017  reading book : time
    Fri May 26 20:13:54 2017 end read book
    Fri May 26 20:13:54 2017 listening music : 好汉歌
    Fri May 26 20:13:59 2017 play music 
    end --- Fri May 26 20:13:59 2017

该段程序顺序执行，但是如果想要表示一边听着音乐一边看书，则无法做到

使用thread模块创建多线程，改进如下：

#coding=utf8
    
    import thread
    from time import ctime,sleep
    
    def readbook(name="time"):
        print "%s reading book : %s"%(ctime(),name)
        sleep(2)
        print "%s end read book"%(ctime())
    
    def listenmusic(name="好汉歌"):
        print "%s listening music : %s"%(ctime(),name)
        sleep(5)
        print "%s end play music " % (ctime())
    
    print "start--- %s"%(ctime())
    thread.start_new_thread(readbook,("oldman",))
    thread.start_new_thread(listenmusic,("the sea",))
    print "end --- %s"%(ctime())

注：  
thread.start\_new\_thread(readbook,(“oldman”,))传入参数时，”oldman”,逗号是必须的

执行结果：

Unhandled exception in thread started by 
    start--- Fri May 26 22:20:12 2017
    sys.excepthook is missing
    end --- Fri May 26 22:20:12 2017Fri May 26 22:20:12 2017  reading book : oldman
    lost sys.stderr

可以看到程序抛出异常，并且显示readbook程序刚执行就已经退出，这是thread的弊端，没有守护进程，主程序退出，子程序也被强制退出  
若要正常执行完成，可以使用sleep等待时间：  
修改为

print "start--- %s"%(ctime())
    thread.start_new_thread(readbook,("oldman",))
    thread.start_new_thread(listenmusic,("the sea",))
    sleep(8)
    print "end --- %s"%(ctime())

执行结果：

start--- Fri May 26 22:23:55 2017
    Fri May 26 22:23:55 2017  reading book : oldman
    Fri May 26 22:23:55 2017 listening music : the sea
    Fri May 26 22:23:57 2017 end read book
    Fri May 26 22:24:00 2017 end play music 
    end --- Fri May 26 22:24:03 2017

但是sleep的时间并不能一直都能计算准确，若计算失误，仍有可能出现异常

#### 使用锁机制解决thread的退出异常 ####

# coding=utf8
    
    import thread
    from time import sleep, ctime
    import random
    
    
    def readbook(lock,name="time", s=0):
        print "%s reading book : %s" % (ctime(), name)
        sleep(s)
        print "%s end read book" % (ctime())
        lock.release()
    
    
    def listenmusic(lock,name="好汉歌", s=0):
        print "%s listening music : %s" % (ctime(), name)
        sleep(s)
        print "%s end play music " % (ctime())
        lock.release()
    
    
    functions = ["readbook", "listenmusic"]
    
    def main():
        print 'the start : %s'%(ctime())
        locks={}
    
        for i in functions:
            locks[i] = thread.allocate_lock()
            locks[i].acquire()
    
        thread.start_new_thread(readbook, (locks["readbook"],"man", random.randint(1, 5),))
        sleep(0.1)
        thread.start_new_thread(listenmusic, (locks["listenmusic"],"the sea", random.randint(1, 5),))
    
        print thread.LockType
    
        for i in functions:
           while locks[i].locked():
              pass
    
        print "end --- %s" % (ctime())
    
    if __name__ == '__main__':
        main()

这里使用锁，然后进行while盲等待：

for i in functions:
           while locks[i].locked():
              pass

执行结果：

the start : Fri May 26 23:06:38 2017
    Fri May 26 23:06:38 2017  reading book : man
    <type 'thread.lock'>
    Fri May 26 23:06:38 2017 listening music : the sea
    Fri May 26 23:06:41 2017 end play music 
    Fri May 26 23:06:42 2017 end read book
    end --- Fri May 26 23:06:42 2017

thread.LockType显示锁的类型：