Python通过两个标准库(thread, threading)提供了对多线程的支持

thread模块

import time
import thread  

def runner(arg):
    for i in range(6):
        print str(i)+':'+arg  

        time.sleep(1)
    #结束当前线程
    thread.exit_thread()  #等同于thread.exit()  

#启动一个线程,第一个参数为函数名,
#第二个参数为一个tuple类型,是传给函数的参数
thread.start_new_thread(runner, ('hello world',))   #等同于thread.start_new(runner, ('hello world'))  

#创建一个锁,锁用于线程同步,通常控制对共享资源的访问
lock = thread.allocate_lock()  #等同于thread.allocate()
num = 0
#获得锁,成功返回True,失败返回False
if lock.acquire():
    num += 1
    #释放锁
    lock.release()
#thread模块提供的线程都将在主线程结束后同时结束,因此将主线程延迟结束
time.sleep(10)
print 'num:'+str(num)  

threading.Thread类的常用方法

1.在自己的线程类的__ init__里调用threading.Thread.__init__(self,name=threadname)threadname为线程的名字。
2.run(),通常需要重写,编写代码实现做需要的功能。
3.getName(),获得线程对象名称。
4.setName(),设置线程对象名称。
5.start(),启动线程。
6.join([timeout]),等待另一线程结束后再运行。
7.setDaemon(bool),设置子线程是否随主线程一起结束,必须在start()之前调用。默认为False。
8.isDaemon(),判断线程是否随主线程一起结束。
9.isAlive(),检查线程是否在运行中。

要想创建一个线程对象,只要继承类threading.Thread,然后在__ init__里边调用threading.Thread.__init__()方法即可。重写run()方法,将要实现的功能放到此方法中即可。

class runner(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name
        self.thread_stop = False
    def run(self):
        while not self.thread_stop:
            print str(self.name)+':'+'hello world'
            time.sleep(1)
    def stop(self):
        self.thread_stop = True  

def test():
    t = runner('thread')
    t.start()
    time.sleep(10)
    t.stop()  

if __name__ == '__main__':
    test()  

线程同步(锁)

最简单的同步机制就是锁。锁对象由threading.RLock类创建。线程可以使用锁的acquire()方法获得锁,这样锁就进入locked状态。每次只有一个线程可以获得锁。如果当另一个线程试图获得这个锁的时候,就会被系统变为blocked状态,直到那个拥有锁的线程调用锁的release()方法来释放锁,这样锁就会进入unlocked状态。blocked状态的线程就会收到一个通知,并有权利获得锁。

如果多个线程处于blocked状态,所有线程都会先解除blocked状态,然后系统选择一个线程来获得锁,其他的线程继续blocked。python的threading module是在建立在thread module基础之上的一个module,在thread module中,python提供了用户级的线程同步工具Lock对象。

而在threading module中,python又提供了Lock对象的变种: RLock对象。RLock对象内部维护着一个Lock对象,它是一种可重入的对象。对于Lock对象而言,如果一个线程连续两次进行acquire操作,那么由于第一次acquire之后没有release,第二次acquire将挂起线程。这会导致Lock对象永远不会release,使得线程死锁。

RLock对象允许一个线程多次对其进行acquire操作,因为在其内部通过一个counter变量维护着线程acquire的次数。而且每一次的acquire操作必须有一个release操作与之对应,在所有的release操作完成之后,别的线程才能申请该RLock对象。

我们把修改共享数据的代码称为临界区。必须将所有临界区都封闭在同一个锁对象的acquirerelease之间。

import time
import threading
num=0
lock = threading.RLock()
class runner(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name  

    def run(self):
        global num
        while True:
            if num >= 6: break
            if lock.acquire():
                print "Thread(%s) locked, Number: %d" % (self.name, num)
                time.sleep(1)
            lock.release()
            print "Thread(%s) released, Number: %d" % (self.name, num)
            time.sleep(1)
            num += 1   

def test():
    t1 = runner('thread1')
    t2 = runner('thread2')
    t1.start()
    t2.start()  

if __name__== '__main__':
    test()    

Python thread实现多线程

#-*- encoding: gb2312 -*-
import string, threading, time

def thread_main(a):
  global count, mutex
  # 获得线程名
  threadname = threading.currentThread().getName()

  for x in xrange(0, int(a)):
    # 取得锁
    mutex.acquire()
    count = count + 1
    # 释放锁
    mutex.release()
    print threadname, x, count
    time.sleep(1)

def main(num):
  global count, mutex
  threads = []

  count = 1
  # 创建一个锁
  mutex = threading.Lock()
  # 先创建线程对象
  for x in xrange(0, num):
    threads.append(threading.Thread(target=thread_main, args=(10,)))
  # 启动所有线程
  for t in threads:
    t.start()
  # 主线程中等待所有子线程退出
  for t in threads:
    t.join() 

if __name__ == '__main__':
  num = 4
  # 创建4个线程
  main(4)

Python threading实现多线程

#-*- encoding: gb2312 -*-
import threading
import time

class Test(threading.Thread):
  def __init__(self, num):
    threading.Thread.__init__(self)
    self._run_num = num

  def run(self):
    global count, mutex
    threadname = threading.currentThread().getName()

    for x in xrange(0, int(self._run_num)):
      mutex.acquire()
      count = count + 1
      mutex.release()
      print threadname, x, count
      time.sleep(1)

if __name__ == '__main__':
  global count, mutex
  threads = []
  num = 4
  count = 1
  # 创建锁
  mutex = threading.Lock()
  # 创建线程对象
  for x in xrange(0, num):
    threads.append(Test(10))
  # 启动线程
  for t in threads:
    t.start()
  # 等待子线程结束
  for t in threads:
    t.join() 

[python]多线程模块thread与threading的更多相关文章

  1. python进阶笔记 thread 和 threading模块学习

    Python通过两个标准库thread和threading提供对线程的支持.thread提供了低级别的.原始的线程以及一个简单的锁.threading基于Java的线程模型设计.锁(Lock)和条件变 ...

  2. python 多线程学习

    多线程(multithreaded,MT),是指从软件或者硬件上实现多个线程并发执行的技术 什么是进程? 计算机程序只不过是磁盘中可执行的二进制(或其他类型)的数据.它们只有在被读取到内存中,被操作系 ...

  3. Python多线程及其使用方法

    [Python之旅]第六篇(三):Python多线程及其使用方法   python 多线程 多线程使用方法 GIL 摘要: 1.Python中的多线程     执行一个程序,即在操作系统中开启了一个进 ...

  4. Python多线程(threading模块)

    线程(thread)是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务. ...

  5. Python模块学习:threading 多线程控制和处理

    Reference:http://python.jobbole.com/81546/ threading.Thread Thread 是threading模块中最重要的类之一,可以使用它来创建线程.有 ...

  6. 【python,threading】python多线程

    使用多线程的方式 1.  函数式:使用threading模块threading.Thread(e.g target name parameters) import time,threading def ...

  7. Python多线程练习(threading)

    这几天学习python多线程的时候,试了几次thread模块和threading模块,发现thread模块非常的不好用.强烈不建议大家使用thread,建议使用threading模块,此模块对thre ...

  8. Python标准模块--threading

    1 模块简介 threading模块在Python1.5.2中首次引入,是低级thread模块的一个增强版.threading模块让线程使用起来更加容易,允许程序同一时间运行多个操作. 不过请注意,P ...

  9. python多线程threading.Lock锁用法实例

    本文实例讲述了python多线程threading.Lock锁的用法实例,分享给大家供大家参考.具体分析如下: python的锁可以独立提取出来 mutex = threading.Lock() #锁 ...

随机推荐

  1. Unsupported major.minor version 51.0错误

    错误原因:用jdk7编译的class文件放到基于jdk6运行在tomcat之中,就会报这个错 解决方法:项目------>右键------>属性------>Java Compile ...

  2. Git学习笔记

    1.第一次提交文件的过程:     1)创建代码库:cd到要作为git代码库的文件夹下,执行git init命令.     2)设置邮箱和用户名:设置后才可提交代码,git config user.e ...

  3. 11个审查Linux是否被入侵的方法

    11个审查Linux是否被入侵的方法 一.检查系统日志 lastb命令 检查系统错误登陆日志,统计IP重试次数 二.检查系统用户 1.cat /etc/passwd 查看是否有异常的系统用户 2.gr ...

  4. sqlyog重复使用的方法(30天)

    Sqlyog作为一款可视化的数据库管理工具,各种方便我就不说了,但是未经汉化或者绿色过的软件存在30天的生命期,到期后我们就不可以使用了,要摸卸载重装,我们还可以去修改注册表,来延长它的生命期,具体步 ...

  5. ACM 喷水装置(一)

    喷水装置(一) 时间限制:3000 ms  |  内存限制:65535 KB 难度:3   描述 现有一块草坪,长为20米,宽为2米,要在横中心线上放置半径为Ri的喷水装置,每个喷水装置的效果都会让以 ...

  6. [电子书] 《Android编程入门很简单》

    <Android编程入门很简单>是一本与众不同的Android学习读物,是一本化繁为简,把抽象问题具体化,把复杂问题简单化的书.本书避免出现云山雾罩.晦涩难懂的讲解,代之以轻松活泼.由浅入 ...

  7. 堆的判断(codevs 2879)

    2879 堆的判断  时间限制: 1 s  空间限制: 32000 KB  题目等级 : 黄金 Gold 题解  查看运行结果     题目描述 Description 堆是一种常用的数据结构.二叉堆 ...

  8. NYOJ 93 汉诺塔(三)

    汉诺塔(三) 时间限制:3000 ms  |  内存限制:65535 KB 难度:3   描述 在印度,有这么一个古老的传说:在世界中心贝拿勒斯(在印度北部)的圣庙里,一块黄铜板上插着三根宝石针.印度 ...

  9. 水晶报表(web)表格信息展示

    一.环境安装 开发工具使用VS2010+SAP Crystal Reports13_0+.NETformwork4.0 因为vs2010已经不再集成水晶报表,所以需要我们去找合适的版本下载http:/ ...

  10. [Raobin] Ext.net在多重子父窗体中找到当前窗体的父窗体,并关闭IFrame父窗体

    var closeParentWindow = function () { var currentWin = window; while (top != currentWin) { var prent ...