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

day9---多线程,线程锁,队列

时间:2016-09-23 00:03:07      阅读:203      评论:0      收藏:0      [点我收藏+]

标签:共享资源   thread   处理器   虚拟机   解释器   

进程、线程

http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html

使用threading模块实现多线程编程[综述]
Python这门解释性语言也有专门的线程模型,Python虚拟机使用GIL(Global Interpreter Lock,全局解释器锁)来互斥线程对共享资源的访问,但暂时无法利用多处理器的优势。

        在Python中我们主要是通过thread和 threading这两个模块来实现的,其中Python的threading模块是对thread做了一些包装的,可以更加方便的被使用,所以我们使用 threading模块实现多线程编程。这篇文章我们主要来看看Python对多线程编程的支持。

        在语言层面,Python对多线程提供了很好的支持,可以方便地支持创建线程、互斥锁、信号量、同步等特性。下面就是官网上介绍threading模块的基本资料及功能:

实现模块
        thread:多线程的底层支持模块,一般不建议使用;

        threading:对thread进行了封装,将一些线程的操作对象化。

threading模块
        Thread 线程类,这是我们用的最多的一个类,你可以指定线程函数执行或者继承自它都可以实现子线程功能;

        Timer与Thread类似,但要等待一段时间后才开始运行;

        Lock 锁原语,这个我们可以对全局变量互斥时使用;

        RLock 可重入锁,使单线程可以再次获得已经获得的锁;

        Condition 条件变量,能让一个线程停下来,等待其他线程满足某个“条件”;

        Event 通用的条件变量。多个线程可以等待某个事件发生,在事件发生后,所有的线程都被激活;

        Semaphore为等待锁的线程提供一个类似“等候室”的结构;

        BoundedSemaphore 与semaphore类似,但不允许超过初始值;

        Queue:实现了多生产者(Producer)、多消费者(Consumer)的队列,支持锁原语,能够在多个线程之间提供很好的同步支持。

其中Thread类
        是你主要的线程类,可以创建进程实例。该类提供的函数包括:

        getName(self) 返回线程的名字

        isAlive(self) 布尔标志,表示这个线程是否还在运行中

        isDaemon(self) 返回线程的daemon标志

        join(self, timeout=None) 程序挂起,直到线程结束,如果给出timeout,则最多阻塞timeout秒

        run(self) 定义线程的功能函数

        setDaemon(self, daemonic) 把线程的daemon标志设为daemonic

        setName(self, name) 设置线程的名字

        start(self) 开始线程执行

其中Queue提供的类
        Queue队列

        LifoQueue后入先出(LIFO)队列

        PriorityQueue 优先队列

Python threading模块

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:DCC
import threading
import time
def run(n):
    print("task",n)
    time.sleep(2)
t1 = threading.Thread(target=run,args=("t1",))
t2 = threading.Thread(target=run,args=("t2",))
t1.start()
t2.start()
print(t1.getName())
print(t2.getName())
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:DCC
import threading
import time
class MyThread(threading.Thread):
    def __init__(self,n):
        super(MyThread,self).__init__()
        self.n = n
    def run(self):
        print("running task",self.n)
        time.sleep(3)
t1 = MyThread("t1")
t2 = MyThread("t2")
if __name__ == ‘__main__‘:
    t1.start()
    t2.start()
    print(t1.getName())
    print(t2.getName())


Join & Daemon

一般情况下 主线程是不等待子线程是否执行完成的,只是触发一下,就不管了。


1、join ()方法:主线程A中,创建了子线程B,并且在主线程A中调用了B.join(),那么,主线程A会在调用的地方等待,直到子线程B完成操作后,才可以接着往下执行,那么在调用这个线程时可以使用被调用线程的join方法。
原型:join([timeout])
里面的参数时可选的,代表线程运行的最大时间,即如果超过这个时间,不管这个此线程有没有执行完毕都会被回收,然后主线程或函数都会接着执行的。

import threading  
import time  
class MyThread(threading.Thread):  
        def __init__(self,id):  
                threading.Thread.__init__(self)  
                self.id = id  
        def run(self):  
                x = 0  
                time.sleep(10)  
                print self.id  
  
if __name__ == "__main__":  
        t1=MyThread(999)  
        t1.start()  
        for i in range(5):  
                print i  
#执行结果
0  
1  
2  
3  
4  
999

机器上运行时,4和999之间,有明显的停顿。解释:线程t1 start后,主线程并没有等线程t1运行结束后再执行,而是先把5次循环打印执行完毕(打印到4),然后sleep(10)后,线程t1把传进去的999才打印出来。
现在,我们把join()方法加进去(其他代码不变),看看有什么不一样,例子:

import threading  
import time  
class MyThread(threading.Thread):  
        def __init__(self,id):  
                threading.Thread.__init__(self)  
                self.id = id  
        def run(self):  
                x = 0  
                time.sleep(10)  
                print self.id  
   
if __name__ == "__main__":  
        t1=MyThread(999)  
        t1.start()  
        t1.join()  
        for i in range(5):  
                print i 
#执行结果
999  
0  
1  
2  
3  
4

2、setDaemon()方法。主线程A中,创建了子线程B,并且在主线程A中调用了B.setDaemon(),这个的意思是,把主线程A设置为守护线程,这时候,要是主线程A执行结束了,就不管子线程B是否完成,一并和主线程A退出.这就是setDaemon方法的含义,这基本和join是相反的。此外,还有个要特别注意的:必须在start() 方法调用之前设置,如果不设置为守护线程,程序会被无限挂起。
例子:就是设置子线程随主线程的结束而结束:

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:DCC
import threading
import time
def run(n):
    print("task",n)
    time.sleep(2)
    print("thread done...",n)
start_time = time.time()
t_objs = [] #存线程实例
for i in range(50):
    t = threading.Thread(target=run,args=("t-%s"% i,))
    t.setDaemon(True) #把当前线程设置为守护线程
    t.start()
    t_objs.append(t) # 为了不阻塞后面线程的启动,不在这里join,先放到-个列表里
    # print(t.getName())
#time.sleep(2)
print(threading.active_count())
# for i in t_objs: #循环线程实例列表,等待所有线程执行完毕
#     t.join()
print(time.time()-start_time)


 线程锁

CPU执行任务时,在线程之间是进行随机调度的,并且每个线程可能只执行n条代码后就转而执行另外一条线程。由于在一个进程中的多个线程之间是共享资源和数据的,这就容易造成资源抢夺或脏数据,于是就有了锁的概念,限制某一时刻只有一个线程能访问某个指定的数据。

未枷锁

import threading
import time
NUM = 0
def show():
    global NUM
    NUM += 1
    name = t.getName()
    time.sleep(1)       # 注意,这行语句的位置很重要,必须在NUM被修改后,否则观察不到脏数据的现象。
    print(name, "执行完毕后,NUM的值为: ", NUM)
 
for i in range(10):
    t = threading.Thread(target=show)
    t.start()
print(‘main thread stop‘)

LOCK锁

普通锁,也叫互斥锁,是独占的,同一时刻只有一个线程被放行。

import time
import threading
NUM = 10
def func(lock):
    global NUM
    lock.acquire()  # 让锁开始起作用
    NUM -= 1
    time.sleep(1)
    print(NUM)
    lock.release()  # 释放锁
lock = threading.Lock()  # 实例化一个锁对象
for i in range(10):
    t = threading.Thread(target=func, args=(lock,))  # 记得把锁当作参数传递给func参数
    t.start()


RLock(递归锁)

说白了就是在一个大锁中还要再包含子锁

threading模块的Lock类,它不支持嵌套锁。RLcok类的用法和Lock一模一样,但它支持嵌套,因此我们一般直接使用RLcok类。

import threading, time

def run1():
    print("grab the first part data")
    lock.acquire()
    global num
    num += 1
    lock.release()
    return num
def run2():
    print("grab the second part data")
    lock.acquire()
    global num2
    num2 += 1
    lock.release()
    return num2
def run3():
    lock.acquire()
    res = run1()
    print(‘--------between run1 and run2-----‘)
    res2 = run2()
    lock.release()
    print(res, res2)
if __name__ == ‘__main__‘:
    num, num2 = 0, 0
    lock = threading.RLock()
    for i in range(10):
        t = threading.Thread(target=run3)
        t.start()
while threading.active_count() != 1:
    print(threading.active_count())
else:
    print(‘----all threads done---‘)
    print(num, num2)


时器(Timer)

定时器,指定n秒后执行某操作。很简单但很使用的东西。

from threading import Timer

def hello():

    print("hello, world")

t = Timer(1, hello)  # 表示1秒后执行hello函数

t.start()


信号量(Semaphore)

这种锁允许一定数量的线程同时更改数据,它不是互斥锁。比如地铁安检,排队人很多,工作人员只允许一定数量的人进入安检区,其它的人继续排队。

互斥锁 同时只允许一个线程更改数据,而Semaphore是同时允许一定数量的线程更改数据 ,比如厕所有3个坑,那最多只允许3个人上厕所,后面的人只能等里面有人出来了才能再进去。

import time
import threading
 
def run(n):
    semaphore.acquire()
    print("run the thread: %s" % n)
    time.sleep(1)
    semaphore.release()
 
num = 0
semaphore = threading.BoundedSemaphore(5)  # 最多允许5个线程同时运行
for i in range(20):
    t = threading.Thread(target=run, args=(i,))
    t.start()


事件(Event)

事件主要提供了三个方法 set、wait、clear。

事件机制:全局定义了一个“Flag”,如果“Flag”的值为False,那么当程序执行wait方法时就会阻塞,如果“Flag”值为True,那么wait方法时便不再阻塞。这种锁,类似交通红绿灯(默认是红灯),它属于在红灯的时候一次性阻挡所有线程,在绿灯的时候,一次性放行所有的排队中的线程。

clear:将“Flag”设置为False

set:将“Flag”设置为True

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

import time
import threading
import random

event = threading.Event()

def lighter():
    count = 0
    event.set() #先设置成绿灯
    while True:
        if count > 5 and count < 10:
            #改成红灯
            event.clear() #把标志位清除
            print("\033[41;1m red.....\033[0m")
        elif count > 10:
            event.set() #设置成路灯
            count = 0
        else:
            print("\033[42;1m green \033[0m")
        time.sleep(1)
        count +=1
def car(name):
    while True:
        if event.is_set(): #代表绿灯
            print("[%s] is running " % name)
            time.sleep(2)
        else:
            print("[%s] is waitting....... " % name)
            event.wait()
            print("[%s] green light is on ,start going" % name)

light = threading.Thread(target=lighter,)
light.start()
car1 = threading.Thread(target=car,args=("Tesla",))
car1.start()


队列

通常而言,队列是一种先进先出的数据结构,与之对应的是堆栈这种后进先出的结构。但是在python中,它内置了一个queue模块,它不但提供普通的队列,还提供一些特殊的队列

Queue:先进先出队列

import queue
q = queue.Queue(5)
q.put(11)
q.put(22)
q.put(33)
 
print(q.get())
print(q.get())
print(q.get())


Queue类的参数和方法:

qsize() 获取当前队列中元素的个数,也就是队列的大小

empty() 判断当前队列是否为空,返回True或者False

full() 判断当前队列是否已满,返回True或者False

put(self, block=True, timeout=None)

get(self, block=True, timeout=None)
LifoQueue:后进先出队列

import queue
q = queue.LifoQueue()
q.put(123)
q.put(456)
print(q.get())


PriorityQueue:优先级队列

q = queue.PriorityQueue()
q.put((1,"alex1"))
q.put((1,"alex2"))
q.put((1,"alex3"))
q.put((3,"alex3"))
print(q.get())


生产者消费者模型

import time,random

import queue,threading

q = queue.Queue()

def Producer(name):

  count = 0

  while count <20:

    time.sleep(random.randrange(3))

    q.put(count)

    print(‘Producer %s has produced %s baozi..‘ %(name, count))

    count +=1

def Consumer(name):

  count = 0

  while count <20:

    time.sleep(random.randrange(4))

    if not q.empty():

        data = q.get()

        print(data)

        print(‘\033[32;1mConsumer %s has eat %s baozi...\033[0m‘ %(name, data))

    else:

        print("-----no baozi anymore----")

    count +=1

p1 = threading.Thread(target=Producer, args=(‘A‘,))

c1 = threading.Thread(target=Consumer, args=(‘B‘,))

p1.start()

c1.start()


本文出自 “东风十里柔情” 博客,请务必保留此出处http://xiaofengcanyue.blog.51cto.com/6671161/1855615

day9---多线程,线程锁,队列

标签:共享资源   thread   处理器   虚拟机   解释器   

原文地址:http://xiaofengcanyue.blog.51cto.com/6671161/1855615

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