python核心编程（十五）— 多线程编程

忘是亡心i 2022-07-12 05:06 254阅读 0赞

## 多线程编程 ##

### Python、线程和全局解释器锁 ###

#### 全局解释器锁(GIL) ####

Python 代码的执行由 Python 虚拟机(也叫解释器主循环)来控制。Python 在设计之初就考虑到 要在主循环中,同时只有一个线程在执行,就像单 CPU 的系统中运行多个进程那样,内存中可以存放多个程序,但任意时刻,只有一个程序在 CPU 中运行。同样地,虽然 Python 解释器中可以“运行” 多个线程,但在任意时刻,只有一个线程在解释器中运行。

对 Python 虚拟机的访问由全局解释器锁(GIL)来控制,正是这个锁能保证同一时刻只有一个 线程在运行。在多线程环境中,Python 虚拟机按以下方式执行:

1.  设置 GIL
2.  切换到一个线程去运行
3.  运行:  
    
    
    1.  指定数量的字节码指令,或者
    2.  线程主动让出控制(可以调用 time.sleep(0)) 把线设置为睡眠状态
4.  解锁 GIL
5.  再次重复以上所有步骤

#### 退出线程 ####

当一个线程结束计算,它就退出了。线程可以调用 thread.exit()之类的退出函数,也可以使用 Python 退出进程的标准方法,如 sys.exit()或抛出一个 SystemExit 异常等。不过,你不可以直接 “杀掉”(“kill”)一个线程。

### thread 模块 ###

除了产生线程外,thread 模块也提供了基本的同步数 据结构锁对象(lock object,也叫原语锁,简单锁,互斥锁,互斥量,二值信号量)

thread 模块函数

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>start_new_thread(function, args, kwargs=None)</code></td> 
   <td>产生一个新的线程,在新线程中用指定的参数和可选的 kwargs 来调用这个函数。</td> 
  </tr> 
  <tr> 
   <td><code>allocate_lock()</code></td> 
   <td>分配一个 LockType 类型的锁对象</td> 
  </tr> 
  <tr> 
   <td><code>exit()</code></td> 
   <td>让线程退出</td> 
  </tr> 
 </tbody> 
</table>

LockType 类型锁对象方法

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>acquire(wait=None)</code></td> 
   <td>尝试获取锁对象</td> 
  </tr> 
  <tr> 
   <td><code>locked()</code></td> 
   <td>如果获取了锁对象返回 True,否则返回 False</td> 
  </tr> 
  <tr> 
   <td><code>release()</code></td> 
   <td>释放锁</td> 
  </tr> 
 </tbody> 
</table>

示例：

# coding=utf-8
    import thread
    from time import sleep, ctime
    
    
    def loop0():
        print 'start loop 0 at:', ctime()
        sleep(4)
        print 'loop 0 done at:', ctime()
        return
    
    
    def loop1():
        print 'start loop 1 at:', ctime()
        sleep(2)
        print 'loop 1 done at:', ctime()
        return
    
    
    def main():
        print 'starting at:', ctime()
        thread.start_new_thread(loop0, ())
        thread.start_new_thread(loop1, ())
        sleep(6)
        print 'all DONE at:', ctime()
    
    
    if __name__ == '__main__':
        main()

加锁示例：

#!/usr/bin/env python
    
    import thread
    from time import sleep, ctime
    
    loops = [1, 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))
    
        for i in nloops:
            lock = thread.allocate_lock()
            lock.acquire()
            locks.append(lock)
    
        for i in nloops:
            thread.start_new_thread(loop, (i, loops[i], locks[i]))
        for i in nloops:
            while locks[i].locked():
                print i
                pass
    
        print 'all DONE at:', ctime()
    
    
    if __name__ == '__main__':
        main()

### threading 模块 ###

<table> 
 <thead> 
  <tr> 
   <th>threading 模块对象</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>Thread</code></td> 
   <td>表示一个线程的执行的对象</td> 
  </tr> 
  <tr> 
   <td><code>Lock</code></td> 
   <td>锁原语对象(跟 thread 模块里的锁对象相同)</td> 
  </tr> 
  <tr> 
   <td><code>RLock</code></td> 
   <td>可重入锁对象。使单线程可以再次获得已经获得了的锁(递归锁定)。</td> 
  </tr> 
  <tr> 
   <td><code>Condition</code></td> 
   <td>条件变量对象能让一个线程停下来,等待其它线程满足了某个“条件”。 如,状态的改变或值的改变。</td> 
  </tr> 
  <tr> 
   <td><code>Event</code></td> 
   <td>通用的条件变量。多个线程可以等待某个事件的发生,在事件发生后, 所有的线程都会被激活。</td> 
  </tr> 
  <tr> 
   <td><code>Semaphore</code></td> 
   <td>为等待锁的线程提供一个类似“等候室”的结构</td> 
  </tr> 
  <tr> 
   <td><code>BoundedSemaphore</code></td> 
   <td>与 Semaphore 类似,只是它不允许超过初始值</td> 
  </tr> 
  <tr> 
   <td><code>Timer</code></td> 
   <td>与 Thread 相似,只是,它要等待一段时间后才开始运行。</td> 
  </tr> 
 </tbody> 
</table>

#### Thread 类 ####

用 Thread 类,你可以用多种方法来创建线程。

*  创建一个Thread的实例,传给它一个函数
 *  创建一个Thread的实例,传给它一个可调用的类对象
 *  从Thread派生出一个子类,创建一个这个子类的实例

Thread 对象的函数

<table> 
 <thead> 
  <tr> 
   <th>threading 模块对象</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>start()</code></td> 
   <td>开始线程的执行</td> 
  </tr> 
  <tr> 
   <td><code>run()</code></td> 
   <td>定义线程的功能函数（一般被子类重写）</td> 
  </tr> 
  <tr> 
   <td><code>join(timeout=None)</code></td> 
   <td>程序挂起,直到线程结束;如果给了 timeout,则最多阻塞 timeout 秒</td> 
  </tr> 
  <tr> 
   <td><code>getName()</code></td> 
   <td>返回线程的名字</td> 
  </tr> 
  <tr> 
   <td><code>setName(name)</code></td> 
   <td>设置线程的名字</td> 
  </tr> 
  <tr> 
   <td><code>isAlive()</code></td> 
   <td>布尔标志,表示这个线程是否还在运行中</td> 
  </tr> 
  <tr> 
   <td><code>isDaemon()</code></td> 
   <td>返回线程的 daemon 标志</td> 
  </tr> 
 </tbody> 
</table>

示例：

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:  # start threads
            threads[i].start()
    
        for i in nloops:  # wait for all
            threads[i].join()  # threads to finish
    
        print 'all DONE at:', ctime()
    
    
    if __name__ == '__main__':
        main()

使用可调用的类 示例：

import threading
    from time import sleep, ctime
    
    loops = [4, 2]
    
    
    class ThreadFunc(object):
        def __init__(self, func, args, name=''):
            self.name = name
            self.func = func
            self.args = args
    
        def __call__(self):
            apply(self.func, self.args)
    
    
    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:  # create all threads
            t = threading.Thread(target=ThreadFunc(loop, (i, loops[i]), loop.__name__))
            threads.append(t)
    
        for i in nloops:  # start all threads
            threads[i].start()
    
        for i in nloops:  # wait for completion
            threads[i].join()
    
        print 'all DONE at:', ctime()
    
    
    if __name__ == '__main__':
        main()

#### threading 模块中的其它函数 ####

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>activeCount()</td> 
   <td>当前活动的线程对象的数量</td> 
  </tr> 
  <tr> 
   <td>currentThread()</td> 
   <td>返回当前线程对象</td> 
  </tr> 
  <tr> 
   <td>enumerate()</td> 
   <td>返回当前活动线程的列表</td> 
  </tr> 
  <tr> 
   <td>settrace(func)</td> 
   <td>为所有线程设置一个跟踪函数</td> 
  </tr> 
  <tr> 
   <td>setprofile(func)</td> 
   <td>为所有线程设置一个 profile 函数</td> 
  </tr> 
 </tbody> 
</table>

#### 生产者-消费者问题和 Queue 模块 ####

常用的 Queue 模块的属性

**Queue 模块函数**

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>queue(size)</td> 
   <td>创建一个大小为 size 的 Queue 对象</td> 
  </tr> 
 </tbody> 
</table>

**Queue 对象函数**

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>qsize()</td> 
   <td>返回队列的大小(由于在返回的时候,队列可能会被其它线程修改,所以这个值是近似值)</td> 
  </tr> 
  <tr> 
   <td>empty()</td> 
   <td>如果队列为空返回 True,否则返回 False</td> 
  </tr> 
  <tr> 
   <td>full()</td> 
   <td>如果队列为满返回 True,否则返回 False</td> 
  </tr> 
  <tr> 
   <td>put(item,block=0)</td> 
   <td>把item放到队列中,如果给了block(不为0),函数会一直阻塞到队列中有空间为止</td> 
  </tr> 
  <tr> 
   <td>get(block=0)</td> 
   <td>从队列中取一个对象,如果给了 block(不为 0),函数会一直阻塞到队列中有对象为止</td> 
  </tr> 
 </tbody> 
</table>

### 守护线程 ###

另一个避免使用 thread 模块的原因是,它不支持守护线程。当主线程退出时,所有的子线程不 论它们是否还在工作,都会被强行退出。有时,我们并不期望这种行为。这时就引入了守护线程的概念。

threading 模块支持守护线程,它们是这样工作的:守护线程一般是一个等待客户请求的服务器, 如果没有客户提出请求,它就在那等着。如果你设定一个线程为守护线程,就表示你在说这个线程 是不重要的,在进程退出的时候,不用等待这个线程退出。

如果你的主线程要退出的时候,不用等待那些子线程完成,那就设定这些线程的 daemon 属性。 即在线程开始(调用 thread.start())之前,调用 setDaemon()函数设定线程的 daemon 标志 (thread.setDaemon(True))就表示这个线程“不重要”

### 相关模块 ###

多线程相关的标准库模块

<table> 
 <thead> 
  <tr> 
   <th>模块</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>thread</td> 
   <td>基本的,底级别的线程模块</td> 
  </tr> 
  <tr> 
   <td>threading</td> 
   <td>高级别的线程和同步对象</td> 
  </tr> 
  <tr> 
   <td>Queue</td> 
   <td>提供多线程使用的同步先进先出(FIFO)队列 mutex 互斥对象</td> 
  </tr> 
  <tr> 
   <td>SocketServer</td> 
   <td>具有线程控制的 TCP 和 UDP 管理器</td> 
  </tr> 
 </tbody> 
</table>

--------------------

参考资料：  
Python核心编程  
备注：  
转载请注明出处：[http://blog.csdn.net/wsyw126/article/details/55001199][http_blog.csdn.net_wsyw126_article_details_55001199]  
作者：WSYW126

[http_blog.csdn.net_wsyw126_article_details_55001199]: http://blog.csdn.net/wsyw126/article/details/55001199