您的位置:首页 > 脚本大全 > > 正文

python多线程多种方法(详解python多线程之间的同步一)

更多 时间:2021-10-21 07:06:01 类别:脚本大全 浏览量:494

python多线程多种方法

详解python多线程之间的同步一

引言:

线程之间经常需要协同工作,通过某种技术,让一个线程访问某些数据时,其它线程不能访问这些数据,直到该线程完成对数据的操作。这些技术包括临界区(critical section),互斥量(mutex),信号量(semaphore),事件event等。

event

 threading库中的event对象通过使用内部一个flag标记,通过flag的true或者false的变化来进行操作。

     名称                                      含义
set( ) 标记设置为true
clear( ) 标记设置为false
is_set( ) 标记是否为true
wait(timeout=none) 设置等待标记为true的时长,none为无限等待。等到返回true,等不到返回false
  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • from threading import thread,event
  • import time
  •  
  • def creditor(event:event):
  •  print("什么时候还我钱")
  •  event.wait()
  •  print("我已经等了很长时间了")
  •  
  •  
  • def debtor(event:event,count=10):
  •  print("可以宽裕几天吗?")
  •  money=[]
  •  while true:
  •  print("先还你100")
  •  time.sleep(0.5)
  •  money.append(1)
  •  if len(money)>count:
  •   event.set()
  •   break
  •  print("我已经还完你的钱了")
  •  
  • event=event()
  • c=thread(target=creditor,args=(event,))
  • d=thread(target=debtor,args=(event,))
  • c.start()
  • d.start()
  • 运行结果如下所示:

    python多线程多种方法(详解python多线程之间的同步一)

    可以看到creditor函数中因为event.wait( )线程进入等待状态,此时debtor线程进入运行,当满足条件时event.set( )将标记设置为true,creditor线程开始运行。谁wait就是等到flag变为true,或等到超时变为false。不限制等待的个数。

    wait的使用

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • from threading import event,thread
  •  
  •  
  • def wait(event:event,interval):
  •  while not event.wait(interval):
  •  print("waiting for you")
  •  
  • e=event()
  • thread(target=wait,args=(e,3)).start()
  • e.wait(10)
  • e.set()
  • print("main exit")
  • python多线程多种方法(详解python多线程之间的同步一)

    主线程一开始就wait 10s,waiting线程等待3s返回false,进入循环打印"waiting for you",重复3次,然后主线程set了,这时候waiting线程变为true,不再进入循环。

    lock

    凡是存在资源争用的地方都可以使用锁,从而保证只有一个使用者可以完全使用这个资源

    现在要生产10个杯子,由10个工人开始生产

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • import threading
  • import time
  •  
  • cups=[]
  •  
  • def worker(count=10):
  •  print("我是{},我开始生产了".format(threading.current_thread().name))
  •  flag=false
  •  while true:
  •  if len(cups)>count:
  •   flag=true
  •  time.sleep(0.05)
  •  if not flag:
  •   cups.append(1)
  •  if flag:
  •   break
  •  print("finished.cups={}".format(len(cups)))
  •  
  • for _ in range(10):
  •  threading.thread(target=worker,args=(1000,)).start()
  • 运行结果如下图所示:

    python多线程多种方法(详解python多线程之间的同步一)

    我们明明只需要到1000就会break,但是结果却到了1010个,这就是因为有10个线程,其中每个线程都在增加,但是增加后的数目,其他线程并不会知道(每个线程通过len函数拿到数量,但是刚拿到数字,其他线程就立即更新了)

    这个时候我们就需要锁lock来实现了,一旦线程获得锁,其他试图获取锁的线程将被阻塞

          名称                                含义
    acquire(blocking=true,timeout=-1) 默认阻塞,阻塞可以设置超时时间。非阻塞时,timeout禁止设置。成功获取锁,返回true,否则返回false
    release( ) 释放锁。可以从任何线程释放。已上锁的锁,会抛出runtimeerror异常

    加锁的实现:

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • import threading
  • import time
  •  
  • cups=[]
  • lock=threading.lock()
  •  
  • def worker(count=10):
  •  print("我是{},我开始生产了".format(threading.current_thread().name))
  •  flag=false
  •  while true:
  •  lock.acquire()
  •  if len(cups)>=count:
  •   flag=true
  •  time.sleep(0.005)
  •  if not flag:
  •   cups.append(1)
  •  lock.release()
  •  if flag:
  •   break
  •  print("finished,cups={}".format(len(cups)))
  •  
  • for _ in range(10):
  •  threading.thread(target=worker,args=(1000,)).start()
  • 运行结果如图所示:

    python多线程多种方法(详解python多线程之间的同步一)

    一般来说加锁后还需要一些代码实现,在释放锁之前还有可能抛出异常,一旦出现异常,锁无法释放,但是当前这个线程会因为这个异常而终止,这样会产生死锁,因此使用时要使用如下的方法:

    1,使用try...finally语句保证锁的释放

    2,with安全上下文管理(锁对象支持上下文管理)

    计数器类,用来加,减。

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • import threading
  • import time
  •  
  •  
  • class counter:
  •  def __init__(self):
  •  self._val = 0
  •  self.__lock = threading.lock()
  •  
  •  @property
  •  def value(self):
  •  return self._val
  •  
  •  def inc(self):
  •  try:
  •   self.__lock.acquire()
  •   self._val += 1
  •  finally:
  •   self.__lock.release()
  •  
  •  def dec(self):
  •  with self.__lock:
  •   self._val -= 1
  •  
  •  
  • def run(c: counter, count=100):
  •  for _ in range(count):
  •  for i in range(-50, 50):
  •   if i < 0:
  •   c.dec()
  •   else:
  •   c.inc()
  •  
  •  
  • c = counter()
  • c1 = 10
  • c2 = 1000
  •  
  •  
  • for i in range(c1):
  •  threading.thread(target=run, args=(c, c2)).start()
  •  
  •  
  • while true:
  •  if threading.active_count() == 1:
  •  print(c.value)
  •  break
  • 启动了10个线程,1000次从-50到50进行加减,最后得到0,如果没有加锁处理的话,得到的结果未必是自己想要的。

    锁的使用场景:

    锁适用于访问和修改同一个资源的时候,引起资源争用的情况下。使用锁的注意事项:

    1. 1,少用锁,除非有必要。多线程访问加锁的资源时,由于锁的存在,实际就变成了串行。
    2. 2,加锁时间越短越好,不需要就立即释放锁。
    3. 3,一定要避免死锁,使用with或者try...finally。

    非阻塞锁使用

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • import threading
  • import time
  •  
  •  
  • def worker(tasks):
  •  for task in tasks:
  •  time.sleep(0.001)
  •  if task.lock.acquire(false):
  •   print("{} {} begin to start".format(threading.current_thread(),task.name))
  •  else:
  •   print("{} {} is working".format(threading.current_thread(),task.name))
  •  
  •  
  • class task:
  •  def __init__(self,name):
  •  self.name=name
  •  self.lock=threading.lock()
  •  
  • tasks=[task('task-{}'.format(x)) for x in range(10)]
  •  
  • for i in range(5):
  •  threading.thread(target=worker,name="worker-{}".format(i),args=(tasks,)).start()
  • 运行结果如下图所示:

    python多线程多种方法(详解python多线程之间的同步一)

    总共开启了5个线程,每个线程处理10个任务,因为在if语句里面,task.lock.acquire(false),所以每个线程只有拿到锁是true,其他的线程不会阻塞会返回false。打印"is working"。

    以上所述是小编给大家介绍的python多线程之间的同步详解整合,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对开心学习网网站的支持!

    原文链接:https://blog.51cto.com/berniem2m/2373692

    您可能感兴趣