精华内容
下载资源
问答
  • Python线程锁

    千次阅读 2018-08-04 14:55:41
    线程锁 当一个数据有多个线程都可以对其进行修改的时候,任何一个线程改变它都会对其他线程造成影响,如果我们某一个线程在使用完之前,其他线程不能对其修改,就需要对这个线程增加一个线程锁。 lock lock注重的...

    线程锁

    当一个数据有多个线程都可以对其进行修改的时候,任何一个线程改变它都会对其他线程造成影响,如果我们某一个线程在使用完之前,其他线程不能对其修改,就需要对这个线程增加一个线程锁。

    lock

    lock注重的是局部,某一个变量没有调用完,其他线程不能调用。

    import threading
    import time
    import random
    count = 0
    def get_money(money):
        global count
        count += money
        count += money
        count -= money
    lock = threading.Lock()
    def lock_thread(money):
        # 加锁
        lock.acquire()
        time.sleep(random.randint(1, 3))
        print('当前线程为',threading.current_thread().name)
        get_money(money)
        time.sleep(random.randint(1,3))
        print('当前线程为', threading.current_thread().name)
        # 解锁
        lock.release()
    thread1 = threading.Thread(target=lock_thread,name='thread1',args=(10000,))
    thread2 = threading.Thread(target=lock_thread,name='thread2',args=(15000,))
    thread1.start()
    thread2.start()
    print('hello world')

    输出结果为:

    hello world
    当前线程为 thread1
    当前线程为 thread1
    当前线程为 thread2
    当前线程为 thread2

    join

    join注重的是整体,线程1没有执行完,线程2不能执行。

    import threading
    import time
    import random
    count = 0
    def get_money(money):
        global count
        count += money
        count += money
        count -= money
    def lock_thread(money):
        time.sleep(random.randint(1, 3))
        print('当前线程为',threading.current_thread().name)
        get_money(money)
        time.sleep(random.randint(1,3))
        print('当前线程为', threading.current_thread().name)
    thread1 = threading.Thread(target=lock_thread,name='thread1',args=(10000,))
    thread2 = threading.Thread(target=lock_thread,name='thread2',args=(15000,))
    thread1.start()
    
    thread1.join()
    
    thread2.start()
    print('hello world')

    执行结果为:

    当前线程为 thread1
    当前线程为 thread1
    hello world
    当前线程为 thread2
    当前线程为 thread2

     

    展开全文
  • python 线程锁

    千次阅读 2018-01-21 13:23:51
    为了多个线程同时操作一个内存中的资源时不产生混乱,我们使用。 Lock(指令)是可用的最低级的同步指令。Lock处于锁定状态时,不被特定的线程拥有。Lock包含两种状态——锁定和非锁定,以及两个基本的方法。 ...

    由于线程之间随机调度:某线程可能在执行n条后,CPU接着执行其他线程。为了多个线程同时操作一个内存中的资源时不产生混乱,我们使用锁。

    Lock(指令锁)是可用的最低级的同步指令。Lock处于锁定状态时,不被特定的线程拥有。Lock包含两种状态——锁定和非锁定,以及两个基本的方法。

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


    创建锁:

    lock=threading.Lock()   

    cond=threading.Condition(lock=lock)

    锁的方法:

    cond.acquire():  获得锁

    cond.wait()           等待通知

    cond.notify()        通知正在等待的锁

    cond.notify_all()   通知所有正在等待的锁

    cond.release()       释放锁

    实例:

    当多线程争夺锁时,允许第一个获得锁的线程进入临街区,并执行代码。
    所有之后到达的线程将被阻塞,直到第一个线程执行结束,退出临街区,
    并释放锁。需要注意,那些阻塞的线程是没有顺序的。

    import threading,time
    lista=[]
    class huofu(threading.Thread):
        def run(self):
            while True:
                condchi.acquire()    #给吃货上锁怕他偷吃馒头
                if len(lista)==0:
                    for i in range(1,11):  #生产馒头
                        lista.append(i)
                        print("正在生产第{}个馒头".format(i))
                        time.sleep(1)
                    condchi.notify_all()      #馒头已经生产完毕,通知吃货准备吃馒头
                condchi.release()             #给吃货解锁
    class chihuo(threading.Thread):
        def __init__(self,name):
            threading.Thread.__init__(self)
            self.name=name
        def run(self):
            mantou=[]
            while True:
                condchi.acquire()   #吃货抢锁谁抢到谁进去吃馒头
                if len(lista)>0:
                    mantou=lista.pop()  #吃馒头
                    time.sleep(1)
                else:
                    condhuo.acquire()   #获得伙夫的锁
                    condhuo.notify()    #通知伙夫准备做馒头
                    condhuo.release()   #释放伙夫的锁
                    condchi.wait()      #没馒头了吃货等待
                condchi.release()       #释放吃货的锁
                if mantou not in lista:
                    print("{}在吃第{}个馒头".format(self.name,mantou))
    lock1=threading.Lock()
    condhuo=threading.Condition(lock1)
    lock2=threading.Lock()
    condchi=threading.Condition(lock2)
    huofu1=huofu()
    chihuo1=chihuo("handao")        #生成吃货一
    chihuo2=chihuo("tanzhenghua")  #生成吃货二
    chihuo3=chihuo("laowang")     #吃货三
    huofu1.start()
    chihuo1.start()
    chihuo2.start()
    chihuo3.start()

    
    


    展开全文
  • python线程锁

    2015-11-05 11:07:35
    # -*- coding:UTF-8 -*- ''' Created on 2015年10月25日 @author: young ''' import threading balance = 0 lock = threading.Lock() def run_thread(n): for i in range(100000): # 先要获取: lo


    # -*- coding:UTF-8 -*-
    '''
    Created on 2015年10月25日
    
    @author: young
    '''
    
    import threading
    
    balance = 0
    lock = threading.Lock()
    
    def run_thread(n):
        for i in range(100000):
            # 先要获取锁:
            lock.acquire()
            try:
                pass
            finally:
                # 改完了一定要释放锁:
                lock.release()
    
    
    


    展开全文
  • python线程锁和进程锁

    千次阅读 2019-06-15 20:54:01
    python的多线程和多进程中,当我们需要对多线程或多进程的共享资源或对象进行修改操作时,往往会出现因cpu随机调度而导致结果和我们预期不一致的问题,这时就需要对线程或者进程加锁,以保证一个线程或进程在对...

           在python的多线程和多进程中,当我们需要对多线程或多进程的共享资源或对象进行修改操作时,往往会出现因cpu随机调度而导致结果和我们预期不一致的问题,这时就需要对线程或者进程加锁,以保证一个线程或进程在对共享对象进行修改时,其他的线程或进程无法访问这个对象,直至获取锁的线程的操作执行完毕后释放锁。所以,锁在多线程和多进程中起到一个同步的作用,以保护每个线程和进程必要操作的完整执行。

           python中,多线程和多进程的异同点主要在两大处:1、由于GIL机制,多线程只能实现并发,但多进程可以实现并行;2、同一个进程中的多线程是共享内存的,线程没有独立的内存,但是进程有独立的内存,所以多进程中的每个子进程是有自己的独立内存的,所以在多进程中,其之间的同名变量并不会冲突,是独立的。第一点异同往往决定我们的任务时该使用多进程还是多线程,如果是I/O密集型任务,考虑多线程,如果是计算密集型任务,考虑多进程;第二点异同会引出本文的重点,即两者在加锁的方式上是不一样的。

           首先讲一下加锁的机制,其是如何实现线程或进程保护的。这个实现的大致过程为:首先在需要同步的代码块前面加上lock.acquire()语句,表示需要先成功获取该锁,才能继续执行下面的代码,然后在需要同步的代码块后面加上lock.release()语句,表示释放该锁。所以,如果当一个线程或进程获取该锁,而且该锁没有被释放的话,那么其他的线程或进程是无法成功获取该锁的,从而也就没法执行下面的同步代码块,从而起到保护作用,直至释放该锁,其他的线程或进程才可以成功获取该锁,然后继续执行下面的代码块。通过上述,一个明显的基本前提是,不同线程或进程面对的锁必须是同一把锁,即同步代码块前后的lock对象必须是同一个,不然如果每个线程或进程有自己不同的锁,那么这个锁也就自然起不到保护作用了。

           由于多线程共享内存,所以我们只要在该进程中创建一个锁,然后锁定相应的代码块即可,因为内存的共享,使得不同子线程面对的就是同一把锁,如下代码所示。这样可以使得每个线程对x进行修改后,x最后依然保持原值。

    from threading import Thread,Lock
    
    lock=Lock()
    x=1
    def f(x):
        global x
        lock.acquire()
        x+=1
        x-=1
        lock.release()
    
    if __name=='__main__':
        t1=Thread(target=f,args=(1,))
        t2=Thread(target=f,args=(2,))
        t1.start()
        t2.start()
        t1.join()
        t2.join()

           但是在多进程中,由于每个子进程都会有自己的独立内存,所以如果按以上方式创建进程,那么实际上在函数f中的lock对象会根据LEGB原则读取到外面的lock对象,也就是说lock=Lock()这条语句也会被包括进每个子进程中,从而每个子进程不仅会在内存创建函数f,也会创建自己独立的锁对象,这样违背了一锁原则,从而无法起到同步作用。所以多进程中正确的加锁方式应该是先在主进程中创建一个锁,然后以参数的形式传给每个进程,这样相当于不同的子进程面对的是同一个锁。虽然实际上,每个子进程还是会在自己的内存中保存自己的锁对象,即如果获取每个进程的锁的id,那么其id还是不同的,说明其是不同的对象,但是因为这个锁的对象是在主进程创建的,子进程只是在自己的内存中复制了主进程中锁的状态,所以尽管不同子进程内存中也有自己的锁对象,但是这个锁对象的状态是一样的,这是最本质的,即我们实际上是需要不同线程或进程的锁是同步的,状态是一致,就可以认为是同一把锁,从而可以实现保护作用。具体的实现方式见如下代码。这样可以实现一个进程的两个print都执行完之后,另一个进程才会print,这一般在I/O里面多进程文件写入时会遇到。

    from multiprocessing import Process,Lock
    import time
    
    def f(x,lock):
        lock.acquire()
        print(x+'1',id(lock))
        time.sleep(5)
        print(x+'2',id(lock))
        lock.release()
    
    if __name__=='__main__':
        lock=Lock()
        p1=Process(target=f,args=('x',lock))
        p2=Process(target=f,args=('y',lock))
        p1.start()
        p2.start()
        p1.join()
        p2.join()

           最后需要注意的一点是,创建多线程或多进程,都必须要先经过主模块判断,即必须在if __name__=='__main__':语句之后才行,这是为了保护资源的一种强制性机制。

    展开全文
  • threading库:Python线程锁与释放锁

    千次阅读 2021-05-11 18:51:57
    with lock 前文,我们通过lock.acquire()与lock.release()实现了的获取与释放,但其实我们Python还给我们提供了一个更简单的语法,通过with lock来获取与释放。 示例如下: import threading import time class...
  • python线程锁实践实例

    千次阅读 2016-07-13 16:38:26
    写这篇文章之前,我想起了一句实践出真知的诗,感觉就在嘴边但就是记不起来,最后百度之。 。 。 。 。...线程锁必须是全局的,这样方能实现在主线程(就是进程)和子线程之间切换。   注意点三
  • python线程锁使用

    2019-01-15 15:45:24
    第二段程序使用了线程锁u=threading.Lock(),在线程中使用u.aquire()锁住对内存数据的操作,从而不会出现两个线程同时做对n加1的操作。 其中task1.start()为开始task1线程,task1.join()为等待task1线程执行结束后...
  • python 线程锁的使用

    2017-01-05 11:27:55
    python线程中,哪些公共资源需要加锁,哪些不需要加锁
  • 1.线程锁(Lock) Lock(指令锁)是可用的最低级的同步指令。Lock处于锁定状态时,不被特定的线程拥有。Lock包含两种状态——锁定和非锁定,以及两个基本的方法。 可以认为Lock有一个锁定池,当线程请求锁定时,将...
  • PYTHON 线程锁释放的时间

    千次阅读 2018-05-27 09:55:48
    为了多个线程同时操作一个内存中的资源时不产生混乱,我们使用。Lock(指令)是可用的最低级的同步指令。Lock处于锁定状态时,不被特定的线程拥有。Lock包含两种状态——锁定和非锁定,以及两个基本的方法。可以...
  • python 线程锁 语法 from threading import Lock lock = Lock() #创建锁对象 lock.acquire() #上锁,若lock已经上锁再调用会阻塞 lock.release() #解锁 with lock: #上锁(代码执行完自动解锁) 示例 from ...
  • Python中线程同步与线程锁

    千次阅读 2019-06-09 21:12:02
    文章目录Python中线程同步与线程锁线程同步threading.Event对象threading.Timer定时器,延迟执行threading.Lock锁可重入锁RLockCondition条件锁,等待通知therading.Semaphore信号量threading.BoundedSemaphore有界...
  • Python中的线程锁

    2019-02-14 09:12:18
    Python中的线程锁 文章目录Python中的线程锁前言为什么需要线程锁LockRLock感谢 前言 尽管Python中的线程有些鸡肋,但在IO操作中,提速显然。然而线程存在一个缺点,你可能不得不费点心力去关注线程同步的问题。...
  • 线程锁:目的是将一段代码锁住,一旦获得所权限,除非释放线程锁,否则其他代码都无法获得锁权限。 为什么需要线程锁? 多线程同时完成特定的操作时,由于并不是原子操作,所以在完成操作的过程中会被打断去做其他的...
  • 当我们使用多线程的时候,每一个进程中只有一个GIL,那么这多个线程中谁拿到GIL,谁就可以使用cpu(ps:多个进程有多个GIl,但每个进程中只有一个GIL),所以当python用cpython作为解释器的时候,多线程就不是真正...
  • 原语锁定(或互斥锁定)是一个...如果有多个线程等待获取锁定,当锁定释放时,只有一个线程能获得它。等待线程获得锁定的顺序没有定义。 使用下面的构造函数可以创建新的Lock实例: Lock() 创建新的Lock对象,初始化为
  • python多线程和线程锁

    2019-11-29 10:45:09
    那么体现在多线程中就是,在“报数”这个过程中,应该上一把,去保证每次只能有一个人报数,报完数拿到最新的人数之后,下一个人才能继续报数。下面是具体演示代码: 1、没上的: from threading import ...
  • 关于python线程condition的注意事项 1.condition中的wait方法会释放其自身所占有的让给其他线程使用,直到通过notify_all()或notify()方法唤醒(或者其sleep的时间到达),唤醒之后继续接着执行wait之后的步骤...
  • python3之线程锁

    2020-03-24 21:34:24
    因此我们需要线程锁来解决数据冲突!!! 线程锁 多线程访问数据,会出现数据冲突的问题,应该怎么解决? 类似生活中,我们可以针对正在访问的数据进行锁定,某一个时刻只能让当前线程访问数据,直到当前线程开锁...
  • python多线程,线程锁

    万次阅读 2019-01-19 23:39:10
    python使用多线程, 不一定运行速度快,这里引入GIL(global interpreter lock) python解释器中任意时刻都只有一个线程在执行; GIL执行过程: 1). 设置一个GIL; 2). 切换线程去准备执行任务(Runnale就绪状态)...
  • 线程锁(互斥锁Mutex) 一个进程下可以启动多个线程,多个线程共享父进程的内存空间,也就意味着每个线程可以访问同一份数据,此时,如果2个线程同时要修改同一份数据,会出现什么状况?就会可能存在同时取出了一个...
  • Python的threading模块中提供了多种锁的相关方法,Python的多线程不能同时执行,因而锁的使用非常关键,下面我们就来举例讲解Python编程中对线程锁的使用:
  • Python线程锁详解

    千次阅读 2017-07-26 18:08:20
    线程锁 Lock 多线程和多进程最大的不同在于,多进程中,同一个变量,各自有一份拷贝存在于每个进程中,互不影响,而多线程中,所有变量都由所有线程共享,所以,任何一个变量都可以被任何一个线程修改,因此,线程...
  • python线程锁机制

    2018-04-11 22:04:49
    在多线程编程中常用到的一个概念就是,它用于将线程需要独占的资源进行加锁,使用后再进行释放,防止死锁发生。此处给出一个不加锁的多线程例子(实现整数n在每个线程内加1并打印):#!/usr/bin/python # -*- ...
  • def sayhi(num): #定义每个线程要运行的函数 print("running on number:%s" %num) time.sleep(3) if __name__ == '__main__': t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例,注意args=...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,141
精华内容 23,256
关键字:

python线程锁

python 订阅