python_Day42_锁和队列详解编程语言

python_Day42_锁和队列

例：多个线程抢占资源的情况 
from threading import Thread 
import time 
 
def work(): 
    global n 
    temp = n 
    time.sleep(0.1) 
    n = temp - 1 
 
if __name__ == '__main__': 
    n = 100 
    l = [] 
 
    for i in range(100): 
        p = Thread(target=work) 
        l.append(p) 
        p.start() 
 
    for p in l: 
        p.join() 
 
    print(n) # 很有可能n=99 
 
这个时候为了保障数据的安全，我们可以对公共数据使用锁锁起来。 
import threading 
R=threading.Lock() 
R.acquire() 
''' 
对公共数据的操作 
''' 
R.release() 
 
例：加锁同步数据 
from threading import Thread,Lock 
import time 
 
def work(): 
    global n 
    lock.acquire() 
    temp=n 
    time.sleep(0.1) 
    n=temp-1 
    lock.release() 
 
if __name__ == '__main__': 
    lock=Lock() 
    n=100 
    l=[] 
    for i in range(100): 
        p=Thread(target=work) 
        l.append(p) 
        p.start() 
    for p in l: 
        p.join() 
 
    print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全。 
 
例：互斥锁与join的区别 
#不加锁:并发执行,速度快,数据不安全 
from threading import current_thread,Thread,Lock 
import time 
def task(): 
    global n 
    print('%s is running' %current_thread().getName()) 
    temp=n 
    time.sleep(0.5) 
    n=temp-1 
 
if __name__ == '__main__': 
    n=100 
    lock=Lock() 
    threads=[] 
    start_time=time.time() 
    for i in range(100): 
        t=Thread(target=task) 
        threads.append(t) 
        t.start() 
    for t in threads: 
        t.join() 
 
    stop_time=time.time() 
    print('主:%s n:%s' %(stop_time-start_time,n)) 
 
''' 
Thread-1 is running 
Thread-2 is running 
...... 
Thread-100 is running 
主:0.5216062068939209 n:99 
''' 
 
#部分数据加上同步锁:未加锁部分并发执行，加锁部分串行执行,速度慢,数据安全。 
from threading import current_thread,Thread,Lock 
import time 
def task(): 
    #未加锁的代码并发运行 
    time.sleep(3) 
    print('%s start to run' %current_thread().getName()) 
    global n 
    #加锁的代码串行运行 
    lock.acquire() 
    temp=n 
    time.sleep(0.5) 
    n=temp-1 
    lock.release() 
 
if __name__ == '__main__': 
    n=100 
    lock=Lock() 
    threads=[] 
    start_time=time.time() 
    for i in range(100): 
        t=Thread(target=task) 
        threads.append(t) 
        t.start() 
    for t in threads: 
        t.join() 
    stop_time=time.time() 
    print('主:%s n:%s' %(stop_time-start_time,n)) 
 
''' 
Thread-1 is running 
Thread-2 is running 
...... 
Thread-100 is running 
主:53.294203758239746 n:0 
''' 
 
#加锁会让运行变成串行,而在start之后立即使用join,不用加锁了也是串行的效果。那么为什么使用加锁呢？ 
#在start之后立刻使用jion,也会将100个任务的执行变成串行,最终n的结果是0,也是安全的, 
#但问题是start后立即join:任务内的所有代码都是串行执行的, 
#而加锁,只是加锁的部分即修改共享数据的部分是串行的, 
#单从保证数据安全方面,二者都可以实现,但很明显是加锁的效率更高. 
 
from threading import current_thread,Thread,Lock 
import time 
def task(): 
    time.sleep(3) 
    print('%s start to run' %current_thread().getName()) 
    global n 
    temp=n 
    time.sleep(0.5) 
    n=temp-1 
 
if __name__ == '__main__': 
    n=100 
    lock=Lock() 
    start_time=time.time() 
    for i in range(100): 
        t=Thread(target=task) 
        t.start() 
        t.join() 
    stop_time=time.time() 
    print('主:%s n:%s' %(stop_time-start_time,n)) 
 
''' 
Thread-1 start to run 
Thread-2 start to run 
...... 
Thread-100 start to run 
主:350.6937336921692 n:0 #耗时是多么的恐怖 
'''

死锁与递归锁死锁与递归锁

死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象。
若无外力作用，它们都将无法推进下去。
此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

如下就是死锁: 
from threading import Lock as Lock 
import time 
mutexA=Lock() 
mutexA.acquire() 
mutexA.acquire() 
print("铁乐猫") 
mutexA.release() 
mutexA.release()

解决方法，递归锁.

在Python中为了支持在同一线程中多次请求同一资源，python提供了递归锁RLock。
这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。
直到一个线程所有的acquire都被release，其他的线程才能获得资源。
上面的例子如果使用RLock代替Lock，则不会发生死锁：

from threading import RLock as Lock 
import time 
mutexA=Lock() 
mutexA.acquire() 
mutexA.acquire() 
print("铁乐猫") 
mutexA.release() 
mutexA.release() 
 
死锁典型例子：科学家吃面 
import time 
from threading import Thread,Lock 
noodle_lock = Lock() 
fork_lock = Lock() 
def eat1(name): 
    noodle_lock.acquire() 
    print('%s 抢到了面条'%name) 
    fork_lock.acquire() 
    print('%s 抢到了叉子'%name) 
    print('%s 吃面'%name) 
    fork_lock.release() 
    noodle_lock.release() 
 
def eat2(name): 
    fork_lock.acquire() 
    print('%s 抢到了叉子' % name) 
    time.sleep(1) 
    noodle_lock.acquire() 
    print('%s 抢到了面条' % name) 
    print('%s 吃面' % name) 
    noodle_lock.release() 
    fork_lock.release() 
 
for name in ['tiele','mao','铁乐猫']: 
    t1 = Thread(target=eat1,args=(name,)) 
    t2 = Thread(target=eat2,args=(name,)) 
    t1.start() 
    t2.start() 
 
递归锁解决科学家吃面中的死锁问题 
import time 
from threading import Thread,RLock 
fork_lock = noodle_lock = RLock() 
def eat1(name): 
    noodle_lock.acquire() 
    print('%s 抢到了面条'%name) 
    fork_lock.acquire() 
    print('%s 抢到了叉子'%name) 
    print('%s 吃面'%name) 
    fork_lock.release() 
    noodle_lock.release() 
 
def eat2(name): 
    fork_lock.acquire() 
    print('%s 抢到了叉子' % name) 
    time.sleep(1) 
    noodle_lock.acquire() 
    print('%s 抢到了面条' % name) 
    print('%s 吃面' % name) 
    noodle_lock.release() 
    fork_lock.release() 
 
for name in ['tiele','mao','铁乐猫]: 
    t1 = Thread(target=eat1,args=(name,)) 
    t2 = Thread(target=eat2,args=(name,)) 
    t1.start() 
    t2.start() 
 
 
定时器(Timer) 
定时器，指定n秒后执行某个操作。 
例： 
from threading import Timer 
 
def hello(): 
    print("hello, world") 
 
t = Timer(1, hello) 
t.start()  # after 1 seconds, "hello, world" will be printed

线程队列（queue队列）

queue队列 ：使用import queue，用法与进程中使用Queue一样。

队列长度可为无限或者有限。可通过Queue的构造函数的可选参数maxsize来设定队列长度。
如果maxsize小于1就表示队列长度无限。

调用队列对象的put()方法在队尾插入一个项目。
put()有两个参数，第一个item为必需的，为插入项目的值；
第二个block为可选参数，默认为1。
如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。
如果block为0，put方法将引发Full异常。

调用队列对象的get()方法从队头删除并返回一个项目。
可选参数为block，默认为True。
如果队列为空且block为True，get()就使调用线程暂停，直至有项目可用。
如果队列为空且block为False，队列将引发Empty异常。

python queue 模块有三种队列：

1）class queue.Queue(maxsize=0) #First In First Out 
［FIFO 类似于栈 先进先出］ 
import queue 
 
q=queue.Queue() 
q.put('first') 
q.put('second') 
q.put('third') 
 
print(q.get()) 
print(q.get()) 
print(q.get()) 
''' 
结果(先进先出): 
first 
second 
third 
''' 
 
2）class queue.LifoQueue(maxsize=0) #Last In Fisrt Out 
［LIFO 类似于堆 后进先出］ 
 
import queue 
 
q=queue.LifoQueue() 
q.put('first') 
q.put('second') 
q.put('third') 
 
print(q.get()) 
print(q.get()) 
print(q.get()) 
''' 
结果(后进先出): 
third 
second 
first 
''' 
 
class queue.PriorityQueue(maxsize=0) #存储数据时可设置优先级的队列 
［优先级队列 数字越小（优先级越高）越先取出］ 
 
import queue 
 
q=queue.PriorityQueue() 
#put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高 
q.put((20,'a')) 
q.put((10,'b')) 
q.put((30,'c')) 
 
print(q.get()) 
print(q.get()) 
print(q.get()) 
''' 
结果(数字越小优先级越高,优先级高的优先出队): 
(10, 'b') 
(20, 'a') 
(30, 'c') 
''' 
 
队列中的其它方法： 
Queue.full    # 与maxsize大小对应 
Queue.qsize() # 返回队列的大小 
Queue.empty() # 队列若为空则返回True   
Queue.full()  # 队列若为满则返回True  
Queue.join()  # block（阻塞）直到queue被消费完毕，再执行后面的操作 
 
Queue.get([block[, timeout]]) # 获取队列，timeout等待时间 
Queue.get_nowait()         # 相当Queue.get(False) 
Queue.put(item)            # 非阻塞 写入队列，timeout等待时间 
Queue.put_nowait(item)        # 相当Queue.put(item, False) 
Queue.task_done()  # 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号 
 
例：使用多线程完成队列中的任务 
 
import queue 
import threading 
import time 
import random 
 
q = queue.Queue(0)  # 当有多个线程共享一个东西的时候就可以用它了 
NUM_WORKERS = 3 
 
class MyThread(threading.Thread): 
 
    def __init__(self, input, worktype): 
        self._jobq = input 
        self._work_type = worktype 
        threading.Thread.__init__(self) 
 
    def run(self): 
        while True: 
            if self._jobq.qsize() > 0: 
                self._process_job(self._jobq.get(), self._work_type) 
            else: 
                break 
 
    def _process_job(self, job, worktype): 
        doJob(job, worktype) 
 
 
def doJob(job, worktype): 
    time.sleep(random.random() * 3) 
    print("doing", job, " worktype ", worktype) 
 
 
if __name__ == '__main__': 
    print("begin....") 
    for i in range(NUM_WORKERS * 2): 
        q.put(i)  # 放入到任务队列中去 
    print("job qsize:", q.qsize()) 
 
    for x in range(NUM_WORKERS): 
        MyThread(q, x).start() 
 
运行效果： 
begin.... 
job qsize: 6 
doing 2  worktype  2 
doing 0  worktype  0 
doing 1  worktype  1 
doing 3  worktype  2 
doing 5  worktype  1 
doing 4  worktype  0

end
参考：http://www.cnblogs.com/Eva-J/articles/8306047.html