简要讲解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中死锁的形成示例及死锁情况的防止

死锁示例 搞多线程的经常会遇到死锁的问题,学习操作系统的时候会讲到死锁相关的东西,我们用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多线程编程(六):可重入锁RLock

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Python使用Windows API创建窗口示例【基于win32gui模块】

本文实例讲述了Python使用Windows API创建窗口.分享给大家供大家参考,具体如下: 一.代码 # -*- coding:utf-8 -*- #! python3 import win32gui from win32con import * def WndProc(hwnd,msg,wParam,lParam): if msg == WM_PAINT: hdc,ps = win32gui.BeginPaint(hwnd) rect = win32gui.GetClientRect(hw

python实现通过队列完成进程间的多任务功能示例

本文实例讲述了python实现通过队列完成进程间的多任务功能.分享给大家供大家参考,具体如下: 1.通过队列完成进程间的多任务 import multiprocessing def download_data(q): """下载数据""" # 模拟从网上下载数据 data = [11, 22, 33, 44] # 向队列中写入数据 for temp in data: q.put(temp) print("----数据下载完成并且已存入队

python 进程间数据共享multiProcess.Manger实现解析

一.进程之间的数据共享 展望未来,基于消息传递的并发编程是大势所趋 即便是使用线程,推荐做法也是将程序设计为大量独立的线程集合,通过消息队列交换数据. 这样极大地减少了对使用锁定和其他同步手段的需求,还可以扩展到分布式系统中. 但进程间应该尽量避免通信,即便需要通信,也应该选择进程安全的工具来避免加锁带来的问题. 以后我们会尝试使用数据库来解决现在进程之间的数据共享问题. 1.1 Manager模块介绍 虽然进程间数据独立,但可以通过Manager实现数据共享,事实上Manager的功能远不止于

Python multiprocessing.Manager介绍和实例(进程间共享数据)

Python中进程间共享数据,处理基本的queue,pipe和value+array外,还提供了更高层次的封装.使用multiprocessing.Manager可以简单地使用这些高级接口. Manager()返回的manager对象控制了一个server进程,此进程包含的python对象可以被其他的进程通过proxies来访问.从而达到多进程间数据通信且安全. Manager支持的类型有list,dict,Namespace,Lock,RLock,Semaphore,BoundedSemaph

python使用Queue在多个子进程间交换数据的方法

本文实例讲述了python使用Queue在多个子进程间交换数据的方法.分享给大家供大家参考.具体如下: 这里将Queue作为中间通道进行数据传递,Queue是线程和进程安全的 from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': q = Queue() p = Process(target=f, args=(q,)) p.start()

一个进程间通讯同步的C#框架引荐

 0.背景简介 微软在 .NET 框架中提供了多种实用的线程同步手段,其中包括 monitor 类及 reader-writer锁.但跨进程的同步方法还是非常欠缺.另外,目前也没有方便的线程间及进程间传递消息的方法.例如C/S和SOA,又或者生产者/消费者模式中就常常需要传递消息.为此我编写了一个独立完整的框架,实现了跨线程和跨进程的同步和通讯.这框架内包含了信号量,信箱,内存映射文件,阻塞通道,及简单消息流控制器等组件.这篇文章里提到的类同属于一个开源的库项目(BSD许可),你可以从这里下载到

Python 进程操作之进程间通过队列共享数据,队列Queue简单示例

本文实例讲述了Python 进程操作之进程间通过队列共享数据,队列Queue.分享给大家供大家参考,具体如下: 队列中的数据是放在内存中的,可以通过分布式缓存redis优化队列. demo.py(进程通过队列共享数据): import multiprocessing def download_from_web(q): """下载数据""" # 模拟从网上下载的数据 data = [11, 22, 33, 44] # 向队列中写入数据 for te

利用Python实现Excel的文件间的数据匹配功能

我们知道Excel有一个match函数,可以做数据匹配. 比如要根据人名获取成绩 而参考表sheet1的内容如下: 要根据sheet1匹配每人的成绩,用Excel是这么写 index(Sheet1!B:B,MATCH(A2,Sheet1!A:A,0)) 意思就是获取sheet1的B列的内容,根据我的A列匹配sheet1的A列的内容 但是如何用python实现这一点呢,我写了一个函数,非常好用,分享给大家. 这个函数考虑到了匹配多个字段,多个sheet. import pandas as pd d