简要讲解Python编程中线程的创建与锁的使用

创建线程
创建线程的两种方法:
1,直接调用threading.Thread来构造thread对象,Thread的参数如下:
class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}) 
group为None;
target为线程将要执行的功能函数;
name为线程的名字,也可以在对象构造后调用setName()来设定;
args为tuple类型的参数,可以为多个,如果只有一个也的使用tuple的形式传入,例如(1,);
kwargs为dict类型的参数,也即位命名参数
threading.Thread对象的其他方法:
start(),用来启动线程;
join(), 等待直到线程结束;
isAlive(),获取线程状态

setDeamon(), 设置线程为deamon线程,必须在start()调用前调用,默认为非demon。
注意: python的主线程在没有非deamon线程存在时就会退出。

threading.currentthread() , 用来获得当前的线程;
threading.enumerate() , 用来多的当前存活的所有线程;

#coding:utf-8
import threading
def func1(num):
 for i in range(num):
  #threading.currentThread()获取当前线程,getName()获取线程名字
  print 'I am %s.num:%s' % (threading.currentThread().getName(), i)

def main(thread_num):
 thread_list = [] #定义一个线程列表
 for i in range(thread_num):
  thread_list.append(threading.Thread(target=func1, args = (3, )))
 for a in thread_list:
  #a.setDaemon(True)这个setDaemon默认为False 非守护线程
  #表示主线程等所有子线程结束后,在结束
  #设置为True的话 表示是个守护线程 子线程就会随着主线程的结束而结束
  #听说服务监控工具生成的心跳线程 就是用的守护线程
  a.start()

 for a in thread_list:
  a.join() #表示等待直到线程运行完毕

main(3)

运行结果

I am Thread-1.num:0
I am Thread-1.num:1
I am Thread-1.num:2
I am Thread-2.num:0
I am Thread-2.num:1
I am Thread-2.num:2
I am Thread-3.num:0
I am Thread-3.num:1
I am Thread-3.num:2

2,直接从threading.Thread继承,然后重写__init__方法和run方法

#coding:utf-8
import threading
class MyThread(threading.Thread): #继承父类threading.Thread
 def __init__(self, num ):
  threading.Thread.__init__(self)
  self.num = num

 #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数
 def run(self):
  for i in range(self.num):
   print 'I am %s.num:%s' % (self.getName(), i)

for i in range(3):
 t = MyThread(3)
 t.start()
 t.join()

运行结果

I am Thread-1.num:0
I am Thread-1.num:1
I am Thread-1.num:2
I am Thread-2.num:0
I am Thread-2.num:1
I am Thread-2.num:2
I am Thread-3.num:0
I am Thread-3.num:1
I am Thread-3.num:2

锁的使用
假设我们有一个公共数据x(也可以叫共享资源,临界资源),然后跑10个线程都去访问这变量并对这个变量进行修改的操作,那么就得到意料之外的结果。

import threading       # 导入threading模块
import time        # 导入time模块
class mythread(threading.Thread):  # 通过继承创建类
 def __init__(self,threadname):  # 初始化方法
  # 调用父类的初始化方法
  threading.Thread.__init__(self,name = threadname)
 def run(self):       # 重载run方法
  global x     # 使用global表明x为全局变量
  for i in range(3):
   x = x + 1
  time.sleep(2)   # 调用sleep函数,让线程休眠5秒
  print x

tl = []        # 定义列表
for i in range(10):
 t = mythread(str(i))    # 类实例化
 tl.append(t)      # 将类对象添加到列表中

x=0         # 将x赋值为0
for i in tl:
 i.start()       # 依次运行线程

运行结果

[root@localhost ~]# python syn.py
30
30
30
30
30
30
30
30
30
30

由于x是全局变量(共享资源),每个线程对x操作后就休眠了
在线程休眠的时候其他线程也都开始执行操作,
最终休眠5秒后x的值最终就被修改为30了

使用互斥锁来保护公共资源。用互斥锁来保证同一时刻只有一个线程访问公共资源,实现简单的同步
互斥锁:threading.Lock 
互斥锁方法:acquire() 获取锁   release():释放锁
当有一个线程获的锁之后,这把锁就会进入locke状态(被锁起来了),另外的线程试图获取锁的时候就会变成同步阻塞状态,
当拥有线程锁的的线程调用锁方法 release()之后就会释放锁,那么锁就会变成开锁unlocked状态,之后再从同步阻塞状态的线程中选择一个来获得锁

import threading       # 导入threading模块
import time        # 导入time模块
class mythread(threading.Thread):     # 通过继承创建类
 def __init__(self,threadname):     # 初始化方法
  threading.Thread.__init__(self,name = threadname)
 def run(self):       # 重载run方法
  global x      # 使用global表明x为全局变量
  lock.acquire()      # 调用lock的acquire方法
  for i in range(3):
   x = x + 1
  time.sleep(2)   # 调用sleep函数,让线程休眠5秒
  print x
  lock.release()    # 调用lock的release方法
lock = threading.Lock()    # 类实例化
tl = []       # 定义列表
for i in range(10):
 t = mythread(str(i))   # 类实例化
 tl.append(t)    # 将类对象添加到列表中

x=0      # 将x赋值为0
for i in tl:
 i.start()      # 依次运行线程

运行结果:

[root@localhost ~]# python syn.py
3
6
9
12
15
18
21
24
27
30

可重入锁:threading.RLock()
方法和互斥锁一样。
假设一个锁嵌套的情况:有个线程以及获取到锁和共享资源了,但是又需要一把锁来获取另外一个资源,那么只要把代码里面的:

lock = threading.Lock()

修改为:

lock = threading.RLock()
时间: 2016-02-27

Python多线程编程(四):使用Lock互斥锁

前面已经演示了Python:使用threading模块实现多线程编程二两种方式起线程和Python:使用threading模块实现多线程编程三threading.Thread类的重要函数,这两篇文章的示例都是演示了互不相干的独立线程,现在我们考虑这样一个问题:假设各个线程需要访问同一公共资源,我们的代码该怎么写? 复制代码 代码如下: ''' Created on 2012-9-8   @author: walfred @module: thread.ThreadTest3 '''  impor

Python中死锁的形成示例及死锁情况的防止

死锁示例 搞多线程的经常会遇到死锁的问题,学习操作系统的时候会讲到死锁相关的东西,我们用Python直观的演示一下. 死锁的一个原因是互斥锁.假设银行系统中,用户a试图转账100块给用户b,与此同时用户b试图转账200块给用户a,则可能产生死锁. 2个线程互相等待对方的锁,互相占用着资源不释放. #coding=utf-8 import time import threading class Account: def __init__(self, _id, balance, lock): sel

Python实现脚本锁功能(同时只能执行一个脚本)

1. 文件锁 脚本启动前检查特定文件是否存在,不存在就启动并新建文件,脚本结束后删掉特定文件. 通过文件的判断来确定脚本是否正在执行. 方法实现也比较简单,这里以python脚本为例 #coding=utf-8 # # 文件锁脚本测试 # import os #操作系统 import time lockfilepath = "/opt/lock.txt"; #判断文件是否存在 if os.path.exists(lockfilepath): #文件存在,说明脚本正在执行 print(&

Python多线程编程(六):可重入锁RLock

考虑这种情况:如果一个线程遇到锁嵌套的情况该怎么办,这个嵌套是指当我一个线程在获取临界资源时,又需要再次获取. 根据这种情况,代码如下: 复制代码 代码如下: ''' Created on 2012-9-8   @author: walfred @module: thread.ThreadTest6 '''    import threading  import time    counter = 0  mutex = threading.Lock()    class MyThread(thr

Python使用文件锁实现进程间同步功能【基于fcntl模块】

本文实例讲述了Python使用文件锁实现进程间同步功能.分享给大家供大家参考,具体如下: 简介 在实际应用中,会出现这种应用场景:希望shell下执行的脚本对某些竞争资源提供保护,避免出现冲突.本文将通过fcntl模块的文件整体上锁机制来实现这种进程间同步功能. fcntl系统函数介绍 Linux系统提供了文件整体上锁(flock)和更细粒度的记录上锁(fcntl)功能,底层功能均可由fcntl函数实现. 首先来了解记录上锁.记录上锁是读写锁的一种扩展类型,它可用于有亲缘关系或无亲缘关系的进程间

python使用fcntl模块实现程序加锁功能示例

本文实例讲述了python使用fcntl模块实现程序加锁功能.分享给大家供大家参考,具体如下: python 中引入给文件加锁的 fcntl模块 import fcntl 打开一个文件 ##当前目录下test文件要先存在,如果不存在会报错.或者以写的方式打开 f = open('./test') 对该文件加密: fcntl.flock(f,fcntl.LOCK_EX) 这样就对文件test加锁了,如果有其他进程对test文件加锁,则不能成功,会被阻塞,但不会退出程序. 解锁:fcntl.floc

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

本文实例讲述了python多线程threading.Lock锁的用法实例,分享给大家供大家参考.具体分析如下: python的锁可以独立提取出来 复制代码 代码如下: mutex = threading.Lock() #锁的使用 #创建锁 mutex = threading.Lock() #锁定 mutex.acquire([timeout]) #释放 mutex.release() 锁定方法acquire可以有一个超时时间的可选参数timeout.如果设定了timeout,则在超时后通过返回值

python线程锁(thread)学习示例

复制代码 代码如下: # encoding: UTF-8import threadimport time # 一个用于在线程中执行的函数def func():    for i in range(5):        print 'func'        time.sleep(1) # 结束当前线程    # 这个方法与thread.exit_thread()等价    thread.exit() # 当func返回时,线程同样会结束 # 启动一个线程,线程立即开始运行# 这个方法与threa

Python多线程编程(五):死锁的形成

前一篇文章Python:使用threading模块实现多线程编程四[使用Lock互斥锁]我们已经开始涉及到如何使用互斥锁来保护我们的公共资源了,现在考虑下面的情况– 如果有多个公共资源,在线程间共享多个资源的时候,如果两个线程分别占有一部分资源并且同时等待对方的资源,这会引起什么问题? 死锁概念 所谓死锁: 是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程.

python避免死锁方法实例分析

本文实例讲述了python避免死锁方法.分享给大家供大家参考.具体分析如下: 当两个或者更多的线程在等待资源的时候就会产生死锁,两个线程相互等待. 在本文实例中 thread1 等待thread2释放block , thread2等待thtead1释放ablock,   避免死锁的原则: 1. 一定要以一个固定的顺序来取得锁,这个列子中,意味着首先要取得alock, 然后再去block 2. 一定要按照与取得锁相反的顺序释放锁,这里,应该先释放block,然后是alock import thre

Python sqlite3事务处理方法实例分析

本文实例讲述了Python sqlite3事务处理方法.分享给大家供大家参考,具体如下: sqlite3事务总结: 在connect()中不传入 isolation_level 事务处理: 使用connection.commit() #!/usr/bin/env python # -*- coding:utf-8 -*- '''sqlite3事务总结: 在connect()中不传入 isolation_level 事务处理: 使用connection.commit() 分析: 智能commit状

Python中replace方法实例分析

本文以实例形式讲述了Python中replace方法,很有实用价值,具体如下: replace方法主要有两种: last_date = "1/2/3" 目标为"123" 方法一:repalce date =last_date.replace('/','') 方法二:re p = re.compile("/") date = p.sub('', last_date) 需要注意的是:一定不要转义,否则函数不会生效. replace 方法返回根据正则表

Python iter()函数用法实例分析

本文实例讲述了Python iter()函数用法.分享给大家供大家参考,具体如下: python中的迭代器用起来非常灵巧,不仅可以迭代序列,也可以迭代表现出序列行为的对象,例如字典的键.一个文件的行,等等. 迭代器就是有一个next()方法的对象,而不是通过索引来计数.当使用一个循环机制需要下一个项时,调用迭代器的next()方法,迭代完后引发一个StopIteration异常. 但是迭代器只能向后移动.不能回到开始.再次迭代只能创建另一个新的迭代对象. 反序迭代工具:reversed()将返回

Python callable()函数用法实例分析

本文实例讲述了Python callable()函数用法.分享给大家供大家参考,具体如下: python中的内建函数callable( ) ,可以检查一个对象是否是可调用的 . 对于函数, 方法, lambda 函数式, 类, 以及实现了 _ _call_ _ 方法的类实例, 它都返回 True. >>> help(callable) Help on built-in function callable in module __builtin__: callable(...) calla

python私有属性和方法实例分析

本文实例分析了python的私有属性和方法.分享给大家供大家参考.具体实现方法如下: python默认的成员函数和成员变量都是公开的,并且没有类似别的语言的public,private等关键词来修饰. 在python中定义私有变量只需要在变量名或函数名前加上 "__"两个下划线,那么这个函数或变量就会为私有的了. 在内部,python使用一种 name mangling 技术,将 __membername替换成 _classname__membername,所以你在外部使用原来的私有成

Python反转序列的方法实例分析

本文实例讲述了Python反转序列的方法.分享给大家供大家参考,具体如下: 序列是python中最基本的数据结构,序列中每个元素都有一个跟位置相关的序号,也称为索引.对于一个有N个元素的序列来说, 从左到右索引:0,1,2,--N-1 从右到左索引:-1,-2,-3---N 1>列表反转 >>> l=[1,2,3,4] >>> ll=l[::-1] >>> l [1, 2, 3, 4] >>> ll [4, 3, 2, 1] &

Python多线程及其基本使用方法实例分析

本文实例讲述了Python多线程及其基本使用方法.分享给大家供大家参考,具体如下: 学习Python的多线程(Multi-threading),至少应该要有进程与线程的基本概念,可以参考:http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html. 1.Python中的多线程 执行一个程序,即在操作系统中开启了一个进程,在某一时刻,一个CPU内核只能进行一个进程的任务,现在的计算机所说的多进程/多任务其实是通过加快CPU的执

python字典get()方法用法分析

本文实例讲述了python字典get()方法用法.分享给大家供大家参考.具体分析如下: 如果我们需要获取字典值的话,我们有两种方法,一个是通过dict['key'],另外一个就是dict.get()方法. 这里给大家分享的就是字典的get()方法. 这里我们可以用字典做一个小游戏,假设用户在终端输入字符串:"1"或者是"2"或者是"3",返回对应的内容,如果是输入其他的,则返回"error" >>> info

python中split方法用法分析

本文实例讲述了python中split方法用法.分享给大家供大家参考.具体分析如下: split 是非常重要的字符串方法,它是join的逆方法,用来将字符串分割成序列 >>> '1+2+3+4+5'.split('+') ['1', '2', '3', '4', '5'] >>> 'usr/bin/env'.split('/') ['usr', 'bin', 'env'] >>> 'usr/bin/env'.split('/') ['usr', 'bi