老男孩IT教育,只培养技术精英

全国免费咨询电话:400-609-2893访问旧版
Python学习必备知识:Python线程那些事

    /    2017-07-13

  Python是每一个源码语言爱好者都必须学习的一个过程,今天小编就Python线程一些知识点跟大家简单的分析一下。

  一、线程创建

  #方法一:将要执行的方法作为参数传给Thread的构造方法

  import threading

  import time

  def show(arg)

  time.sleep(2)

  print('thread' + str(arg))

  for i in range(10

  t = threading.Thread(target=show,args=(i,))

  time.sleep(2)

  t.start()

  方法二:从Thread继承,并重写run()

  class MyThread(threading.Thread)

  def __init__(self,num)

  threading.Thread.__init__(self)

  self.num = num

  def run(self)):#定义每个线程要运行的函数

  print("running on number:%s" %self.num)

  time.sleep(3)

  if __name__ == '__main__'

  t1 = MyThread(1)

  t2 = MyThread(2)

  t1.start()

  time.sleep(3)

  t2.start()

  注解:

  Thread(group=None,target=None,name=None,args=(),kwargs={})

  group:线程组,目前还没有实现,库引用时提示必须是None

  target:要执行的方法

  name:线程名

  args/kwargs:要传入方法的参数,args和kwargs两个参数其实是二选一

  实例方法

  isAlive():返回线程是否在运行

  get/setName(name):获取/设置线程名

  is/setDaemon(bool):获取/设置是否守护线程。初始值从创建该线程的线程继承,当没有非守护线程仍在运行时,程序将终止

  start():启动线程

  join([timeout]):阻塞当前上下文环境的线程。

  二、Python多线程用法

  import threading

  from time import ctime,sleep

  def music(func)

  for i in range(2)

  print("I was listening to %s. %s" %(func,ctime()))

  sleep(1)

  def move(func)

  for i in range(2)

  print("I was at the %s! %s" %(func,ctime()))

  sleep(5)

  threads = []

  t1 = threading.Thread(target=music,args=('童话镇',))

  threads.append(t1)

  t2 = threading.Thread(target=move,args=('变形金刚',))

  threads.append(t2)

  if __name__ == '__main__':

  for t in threads:

  t.setDaemon(True)

  t.start()

  print("all over %s" %ctime())

  注:

  threads = []

  t1 = threading.Thread(target=music,args=('童话镇',))

  threads.append(t1)

  创建了threads数组,创建线程t1,使用threading.Thread()方法,在这个方法中调用music方法target=music,args方法对music进行传参。 把创建好的线程t1装到threads数组中。   接着以同样的方式创建线程t2,并把t2也装到threads数组。

  for t in threads:

  t.setDaemon(True)

  t.start()

  最后通过for循环遍历数组。(数组被装载了t1和t2两个线程)

  setDaemon()

  setDaemon(True)将线程声明为守护线程,必须在start() 方法调用之前设置,如果不设置为守护线程程序会被无限挂起。子线程启动后,父线程也继续执行下去,当父线程执行完最后一条语句print "all over %s" %ctime()后,没有等待子线程,直接就退出了,同时子线程也一同结束。

  serDeamon(False)(默认)前台线程,主线程执行过程中,前台线程也在进行,主线程执行完毕后,等待前台线程也执行完成后,主线程停止。

  运行结果:

  I was listening to 童话镇. Thu Jun 22 23:23:07 2017 I was at the 变形金刚! Thu Jun 22 23:23:07 2017 all over Thu Jun 22 23:23:07 2017

  从执行结果来看,子线程(muisc 、move )和主线程(print "all over %s" %ctime())都是同一时间启动,但由于主线程执行完结束,所以导致子线程也终止。

  调整程序: 复制代码

  if __name__ == '__main__':

  for t in threads:

  t.setDaemon(True)

  t.start()

  t.join()

  print "all over %s" %ctime() 复制代码

  加了join()方法,用于等待线程终止。join()的作用是,在子线程完成运行之前,这个子线程的父线程将一直被阻塞。

  join()方法的位置是在for循环外的,也就是说必须等待for循环里的两个进程都结束后,才去执行主进程。

  运行结果:

  ############运行结果###################

  I was listening to 童话镇. Thu Jun 22 23:34:22 2017

  I was at the 变形金刚! Thu Jun 22 23:34:22 2017

  I was listening to 童话镇. Thu Jun 22 23:34:23 2017

  I was at the 变形金刚! Thu Jun 22 23:34:27 2017

  all over Thu Jun 22 23:34:32 2017

  从结果的时间可以看出每首歌之间等待1秒,电影之间等待5秒,但是是同步进行的,总的时间为5秒

  三、线程锁(LOCK,RLOCK)

  由于线程之间是进行随机调度,并且每个线程可能只执行n条执行之后,当多个线程同时修改同一条数据时可能会出现脏数据,所以,出现了线程锁 - 同一时刻允许一个线程执行操作。   Lock(指令锁)是可用的最低级的同步指令。Lock处于锁定状态时,不被特定的线程拥有。Lock包含两种状态——锁定和非锁定,以及两个基本的方法。

  可以认为Lock有一个锁定池,当线程请求锁定时,将线程至于池中,直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。

  RLock(可重入锁)是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念,处于锁定状态时,RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire(),释放锁时需要调用release()相同次数。

  可以认为RLock包含一个锁定池和一个初始值为0的计数器,每次成功调用 acquire()/release(),计数器将+1/-1,为0时锁处于未锁定状态。

  简言之:Lock属于全局,Rlock属于线程。

  1. 未使用锁

    import threading

  import time

  num = 0

  def show(arg):

  global num

  time.sleep(1)

  num +=1

  print(num)

  for i in range(10):

  t = threading.Thread(target=show, args=(i,))

  t.start()

  print('main thread stop')

  多次运行可能产生混乱。这种场景就是适合使用锁的场景。

  2.使用锁 复制代码

  import threading

  import time

  num = 0

  lock = threading.RLock()

  # 调用acquire([timeout])时,线程将一直阻塞,

  # 直到获得锁定或者直到timeout秒后(timeout参数可选)。

  # 返回是否获得锁。

  def show(arg):

  lock.acquire()

  global num

  time.sleep(1)

  num +=1

  print(num)

  lock.release()

  for i in range(10):

  t = threading.Thread(target=show, args=(i,))

  t.start()

  print('main thread stop') 加上锁后数字会一步步打印出来,不会因为拥堵而错乱的情况!

  四、信号量(Semaphore)

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

  import threading, time

  def run(n):

  semaphore.acquire()

  time.sleep(3)

  print("run the thread: %s" % n)

  semaphore.release()

  if __name__ == '__main__':

  num = 0

  semaphore = threading.BoundedSemaphore(5) # 最多允许5个线程同时运行

  for i in range(20):

  t = threading.Thread(target=run, args=(i,))

  t.start()

  五、事件(event)

  Python线程的事件主要用于主线程控制其他线程的执行,事件主要提供了三个方法:set、wait、clear

  事件处理的机制:

  全局定义了一个“Flag”,如果“Flag”值为 False,那么当程序执行 event.wait 方法时就会阻塞,如果“Flag”值为True,那么event.wait 方法时便不再阻塞。

  clear:将“Flag”设置为False set:将“Flag”设置为True 用threading.Event实现线程间的通讯

  threading.Event使一个线程等待其他线程的通知,把这个Event传递到线程对象中,Event默认内置了一个标志,初始值为False。 一旦该线程通过wait()方法进入等待状态,直到另一个线程调用该Event的set()方法将内置标志设置为True时, 该Event会通知所有等待状态的线程恢复运行。

  复制代码

  import threading

  def do(event)

  print('start')

  event.wait()

  print('end')

  event_obj = threading.Event()

  for i in range(10):

  t = threading.Thread(target=do, args=(event_obj,))

  t.start()

  event_obj.clear() #继续阻塞

  inp = input('input:')

  if inp == 'true'

  event_obj.set() # 唤醒

  六、条件(condition)

  所谓条件变量,即这种机制是在满足特定条件之后,线程才可以访问相关的数据! 它使用Condition类来完成,由于它也可以像锁机制那样用,所以它也有acquire方法和release方法,而且它还有wait,notify,notifyAll方法 一个简单的生产消费者模型,通过条件变量的控制产品数量的增减,调用一次生产者产品就是+1,调用一次消费者产品就会-1. 使用 Condition 类来完成,由于它也可以像锁机制那样用,所以它也有 acquire 方法和 release 方法,而且它还有 wait, notify, notifyAll 方法。

  复制代码

  import threading

  import time

  # 产品类

  class Goods:

  def __init__(self):

  self.count = 0

  def add(self, num=1):

  self.count += num

  def sub(self):

  if self.count >= 0

  self.count -= 1

  def empty(self):

  return self.count <= 0=""

  =""

  =""

  =""

  =""

  =""

  =""

  =""

  =""

  =""

  =""

  =""

  =""

  =""

  =""

  =""

  =""

  =""

  ="" class="" :="" def="" sleeptime="1):" self.cond="condition" self.goods="goods" self.sleeptime="sleeptime" cond="self.cond" goods="self.goods" while="" true:="" -=""> 其实就是唤醒消费者进程

  cond.notifyAll()

  # 解锁资源

  cond.release()

  time.sleep(self.sleeptime)

  # 消费者

  class Consumer(threading.Thread)

  def __init__(self, condition, goods, sleeptime=2)

  threading.Thread.__init__(self)

  self.cond = condition

  self.goods = goods

  self.sleeptime = sleeptime

  def run(self)

  cond = self.cond

  goods = self.goods

  while True

  time.sleep(self.sleeptime)

  # 锁住资源

  cond.acquire()

  # 如无产品则让线程等待

  while goods.empty()

  cond.wait()

  goods.sub()

  print("产品数量:", goods.count, "消费者线程")

  g = Goods() 66 c = threading.Condition()

  pro = Producer(c, g)

  pro.start()

  con = Consumer(c, g)

  con.start()

  七、定时器(Timer)

  import threading

  def SayHello():

  print("hello world!")

  t=threading.Timer(3,SayHello)

  t.start() 6 def other_func()

  print("let me running!")

  t=threading.Timer(1,other_func)

  t.start()

  if __name__ == "__main__"

  SayHello()

  other_func()

(0)

分享至