码迷,mamicode.com
首页 > 编程语言 > 详细

多线程-Threading

时间:2016-05-24 10:36:59      阅读:408      评论:0      收藏:0      [点我收藏+]

标签:threading

线程基础

参看[python线程指南]

http://www.cnblogs.com/huxi/archive/2010/06/26/1765808.html


线程5种状态

- 新建
- 就绪
- 运行
- 阻塞
- 死亡

阻塞的三种情况:

同步阻塞:是指处于竞争锁定的状态,线程请求锁定时将进入这个状态,一旦成功获得锁定又恢复到运行状态;
等待阻塞:是指等待其他线程通知的状态,线程获得条件锁定后,调用“等待”将进入这个状态,一旦其他线程发出通知,线程将进入同步阻塞状态,再次竞争条件锁定;

其他阻塞:是指调用time.sleep()、anotherthread.join()或等待IO时的阻塞,这个状态下线程不会释放已获得的锁定。


GIL

在python虚拟机中的访问由全局解释器锁(GIL)控制,由于有了这把锁能保证同一时刻只有一个线程在运行,在多线程环境下,python虚拟机按照如下方式运行:

  1. 设置GIL

  2. 切换到一个线程中运行

  3. 运行:

    a指定数量的字节码的指令,或者
    b线程主动让出控制(可以调用time.sleep(0))

  4. 把线程设置为睡眠状态

  5. 解锁GIL

  6. 在重复以上所有步骤


threading.Thread模块

threading.Thread 作用:创建线程实例
- start()    开始一个线程的执行
- run()    定义线程的功能的函数(一般会被子类重写)
- join(timeout=None)  程序挂起,直到子线程结束,在执行主线程,如果给了timeout,则最多阻塞timeout秒
- getName()    返回线程的名字
- setName()    设置线程的名字
- isAlive()    检查线程是否成活
- isDaemon()   是否等待线程执行完成后在执行主进程,默认为false
- setDeaemon() 设置为daemoe模式,setDeaemon(True),不等子线程执行完成,直接执行主线程;如果在主线程没有结束时,子线程会执行直到主线程结束,子线程也结束


多线程运行的两种方式

1.函数调用:target传入函数名称,args传递给函数的参数

#!/usr/bin/env python
# encoding: utf-8
from threading import Thread
from time import sleep,ctime,sleep

def myfunction(arg):
    for item in range(10):
        print item
        sleep(1)
print "before"

t1 = Thread(target=myfunction,args=(‘hello‘,))
print t1.getName() #Thread-1
print t1.isDaemon() #默认为false
#t1.setDaemon(True)  #设置为setDaemon模式
t1.start()
t1.join(timeout=5)
print "after"
print "Over"
sleep(5)

2.类继承调用:使用Threading创建线程,从threading.Thread继承,然后重写init方法和run方法

#!/usr/bin/env python
#coding:utf-8

import time
from threading import Thread

class mythread(Thread): #继承父类的threading.Thread
    def __init__(self,threadid,threadname,counter):
        Thread.__init__(self)
        self.threadid = threadid
        self.threadname = threadname
        self.counter = counter
        
    def run(self): #把要执行的代码写在run函数中,线程创建后会直接运行run函数
        print "Starting %s \n" %self.threadname
        print_time(self.name,self.counter,self.threadid) #函数调用
        print "Exiting %s" %self.threadname
        
def print_time(threadName,delay,counter):
    while counter :
        time.sleep(delay)
        print counter,"%s: %s" %(threadName,time.ctime())
        counter -=1
        
t1 = mythread(2,"线程一",1)
t1.start()


生产者消费者模型

优点:

1.解耦:两者都只依赖于缓冲区,不相互依赖
2.支持并发:生产者把制造出来的数据往缓冲区一丢,就可以再去生产下一个数据,即不用依赖消费者的处理速度
3.支持忙闲不均

#!/usr/bin/env python
#coding:utf-8
import threading
import time,random
import Queue

def proudcer(name,que):
    while True:
        if que.qsize() < 3:
            que.put(‘生产包子‘)
            print "%s:生产了一个包子...." %name
        time.sleep(random.randrange(5))
        
def consumer(name,que):
    while True:
        try:
            que.get_nowait() #不等待队列是否有值
            print "%s:消费了一个包子...." %name
        except Exception:
            print u‘没有包子可消费了 .....‘
        time.sleep(random.randrange(3))
        
#实例化生产者
q = Queue.Queue()
p1 = threading.Thread(target=proudcer,args=("生产者01",q))
p2 = threading.Thread(target=proudcer,args=("生产者02",q))
p1.start()
p2.start()

#实例化消费者
c1 = threading.Thread(target=consumer,args=("消费者01",q))
c2 = threading.Thread(target=consumer,args=("消费者02",q))
c1.start()
c2.start()


线程安全-线程锁,保证数据安全

多个线程都同时修改某个变量,有可能出现问题,Lock处于锁定状态时,不被特定的线程拥有。Lock包含两种状态——锁定和非锁定,以及两个基本的方法。
运行:任何时刻只能有一个线程在执行

定义和方法:

lock = threading.Lock() #线程锁定义
lock.acquire() #获取锁,开始独占cpu
slock.release() #释放锁,可以被其他使用cpu资源,必须在获得锁定后再使用,否则抛出异常
slock.locked()  #主程序判断locked()状态
Lock= threading.RLock() #可重入锁,多把锁时引用,释放时也应该释放对应的多把锁
lock = threading.BoundedSemaphore(4) #同时允许多少个线程进行数据修改信号量:同一时刻,允许几个线程运行

#!/usr/bin/env python
#coding:utf-8
import threading
import time

data = 0
lock = threading.Lock() #定义锁

def func():
    global data
    print "%s acquire lock ..." %threading.currentThread().getName()
    #print "acquire-----%s" %lock.acquire()
    if lock.acquire(): #调用锁,返回是否获得锁
        print "%s get the lock." %threading.currentThread().getName()
        data += 1
        print data
        time.sleep(2)
        print "%s release lock..." %threading.currentThread().getName()
        lock.release() # 调用release()将释放锁
        
t1 = threading.Thread(target=func)
t2 = threading.Thread(target=func)
t3 = threading.Thread(target=func)
t1.start()
t2.start()
t3.start()

event = threading.Event()
event.wait()    #将阻塞线程放置为阻塞状态,等待设置处理
event.set()   #event内置了一个初始为false的标示,当调用set时,设置为true,开始处理
event.clear()    #将set标示位清空,设置为false
event.isSet()    #判断set标示位是否为true

本文出自 “天天向上goto” 博客,请务必保留此出处http://ttxsgoto.blog.51cto.com/4943095/1782300

多线程-Threading

标签:threading

原文地址:http://ttxsgoto.blog.51cto.com/4943095/1782300

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!