python之线程锁

码途觅汐使
• 阅读 1515

本文讲python中的四种锁
Lock互斥锁
使用前

num = 0


def a():
    global num
    for _ in range(10000000):
        num += 1


def b():
    global num
    for _ in range(10000000):
        num += 1


if __name__ == '__main__':
    t1=Thread(target=a)
    t1.start()
    t2=Thread(target=b)
    t2.start()
    t1.join()
    t2.join()
    print(num)    #基本永远会小于20000000

使用后

num = 0


def a(lock):
    global num
    for _ in range(1000000):
        with lock:
            num += 1


def b(lock):
    global num
    for _ in range(1000000):
        with lock:
            num += 1


if __name__ == '__main__':
    lock = threading.Lock()
    t1=Thread(target=a, args=(lock,))
    t1.start()
    t2=Thread(target=b, args=(lock,))
    t2.start()
    t1.join()
    t2.join()
    print(num)    #永远会输出20000000

RLock重用锁

#在之前的代码中永远不可能出现锁在没释放之前重新获得锁,但rlock可以做到,但只能发生在一个线程中,如:
num = 0


def a(lock):
    with lock:
        print("我是A")
        b(lock)


def b(lock):
    with lock:
        print("我是b")

if __name__ == '__main__':
    lock = threading.Lock()
    t1 = Thread(target=a, args=(lock,))
    t1.start()    #会发生死锁,因为在第一次还没释放锁后,b就准备上锁,并阻止a释放锁

使用后

if __name__ == '__main__':
    lock = threading.RLock()    #只需要改变锁为RLock程序马上恢复
    t1 = Thread(target=a, args=(lock,))
    t1.start()

Condition同步锁

#这个程序我们模拟甲乙对话
Jlist = ["在吗", "干啥呢", "去玩儿不", "好吧"]
Ylist = ["在呀", "玩儿手机", "不去"]


def J(list):
    for i in list:
        print(i)
        time.sleep(0.1)


def Y(list):
    for i in list:
        print(i)
        time.sleep(0.1)


if __name__ == '__main__':
    t1 = Thread(target=J, args=(Jlist,))
    t1.start()
    t1.join()
    t2 = Thread(target=Y, args=(Ylist,))
    t2.start()
    t2.join()    #上面的程序输出后发现效果就是咱们想要的,但是我们每次输出后都要等待0.1秒,也无法正好确定可以拿到时间片的最短时间值,并且不能保证每次正好都是另一个线程执行。因此,我们用以下方式,完美解决这些问题。

使用后

Jlist = ["在吗", "干啥呢", "去玩儿不", "好吧"]
Ylist = ["在呀", "玩儿手机", "不去","哦"]


def J(cond, list):
    for i in list:
        with cond:
            print(i)
            cond.notify()
            cond.wait()


def Y(cond, list):
    for i in list:
        with cond:
            cond.wait()
            print(i)
            cond.notify()


if __name__ == '__main__':
    cond = threading.Condition()
    t1 = Thread(target=J, args=(cond, Jlist))
    t2 = Thread(target=Y, args=(cond, Ylist))
    t2.start()
    t1.start()    #一定保证t1启动在t2之后,因为notify发送的信号要被t2接受到,如果t1先启动,会发生阻塞。

Seamplore信号量
使用前

class B(threading.Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        time.sleep(1)
        print(self.name)


class A(threading.Thread):
    def __init__(self):
        super().__init__()

    def run(self):
        for i in range(100):
            b = B(i)
            b.start()


if __name__ == '__main__':
    a = A()
    a.start()    #执行后发现不断在输出

使用后

class B(threading.Thread):
    def __init__(self, name, sem):
        super().__init__()
        self.name = name
        self.sem = sem

    def run(self):
        time.sleep(1)
        print(self.name)
        sem.release()


class A(threading.Thread):
    def __init__(self, sem):
        super().__init__()
        self.sem = sem

    def run(self):
        for i in range(100):
            self.sem.acquire()
            b = B(i, self.sem)
            b.start()


if __name__ == '__main__':
    sem = threading.Semaphore(value=3)
    a = A(sem)
    a.start()    #通过执行上面的代码,我们发现一次只能输出三个数字,sem控制访问并发量

Event事件

import time
import threading


class MyThread(threading.Thread):
    def __init__(self, name, event):
        super().__init__()
        self.name = name
        self.event = event

    def run(self):
        print('Thread: {} start at {}'.format(self.name, time.ctime(time.time())))
        # 等待event.set()后,才能往下执行
        self.event.wait()
        print('Thread: {} finish at {}'.format(self.name, time.ctime(time.time())))


event = threading.Event()

# 定义五个线程
threads = [MyThread(str(i), event) for i in range(1,5)]

# 重置event,使得event.wait()起到阻塞作用
event.clear()

# 启动所有线程
[t.start() for t in threads]

print('等待5s...')
time.sleep(5)

print('唤醒所有线程...')
event.set()

# output:
'''
Thread: 1 start at Sun May 13 20:38:08 2018
Thread: 2 start at Sun May 13 20:38:08 2018
Thread: 3 start at Sun May 13 20:38:08 2018
Thread: 4 start at Sun May 13 20:38:08 2018

等待5s...

唤醒所有线程...
Thread: 1 finish at Sun May 13 20:38:13 2018
Thread: 4 finish at Sun May 13 20:38:13 2018
Thread: 2 finish at Sun May 13 20:38:13 2018
Thread: 3 finish at Sun May 13 20:38:13 2018
'''
点赞
收藏
评论区
推荐文章
Wesley13 Wesley13
3年前
java 里面 的锁
A、乐观锁、悲观锁B、偏向锁、轻量级锁、重量级锁C、互斥锁、自旋锁、适应性自旋D、可重入锁、读写锁E、公平锁、非公平锁F、总线锁、缓存锁(linux操作系统底层,由CPU提供的锁)G、锁优化:减少锁持有时间、减小锁粒度、锁分离、锁粗化、锁消除信号量与互斥量:信号
Stella981 Stella981
3年前
Linux中的各种锁及其基本原理
Linux中的各种锁及其基本原理1.概述通过本文将了解到如下内容:Linux系统的并行性特征互斥和同步机制Linux中常用锁的基本特性互斥锁和条件变量2.Linux的并行性特征Linux作为典型的多
Wesley13 Wesley13
3年前
Java并发包小结
1、Lock  Lock功能对应关键字synchrozied功能,lock和unlock方法用于加锁和释放锁。等待锁的线程加入到等待链表中,同时阻塞线程,锁释放时,从等待链表中取出等待的线程执行,取等待的线程分公平与非公平两种方式,公平方式取第一个等待的线程,非公平方式当前正在获取锁的线程可能立刻执行,而不用加入到等待队列中,排队执行。2、Con
Wesley13 Wesley13
3年前
Java并发源码之ReentrantLock
ReentrantLock介绍ReentrantLock是一个可重入的互斥锁,与使用synchronized方法和语句访问的隐式监视锁具有相同的基本行为和语义,但具有扩展功能。ReentrantLock属于最后一个成功加锁并且还没有释放锁的线程。当一个线程请求lock时,如果锁不属于任何线程,将立马得到这个锁;如果锁已经被
Wesley13 Wesley13
3年前
CIL锁,GIL与线程池的区别,进程池和线程池,同步与异步
一.GIL锁什么是GIL?全局解释器锁,是加在解释器上的互斥锁GC是python自带的内存管理机制,GC的工作原理:python中的内存管理使用的是应用计数,每个数会被加上一个整型的计数器,表示这个数据被引用的次数,当这个整数变为0时则表示该数据已经没有人使用,成为了垃圾数据,当内存占用达到某个阈值,GC会将其他线程挂起,然后执行垃圾清理操作,垃圾
Wesley13 Wesley13
3年前
Java学习笔记7
lock接口实现类ReentrantLock我们可以用lock对象,来对临界资源加锁,只有获得lock对象才能访问临界资源,如果没有获得lock对象,就会进入lock对象的锁池。trylock()方法会返回布尔值,这个方法是用来判断这个锁对象是不是已经被线程获取,如果返回值为true,则会直接获得这个锁对象,如果返回false,线程不会阻塞还会继
Stella981 Stella981
3年前
Python的锁
互斥锁锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象,lLock()创建一个锁,初始状态是未锁定当你需要访问该资源时,调用l.acquire方法来获取锁对象(如果其它线程已经获得了该锁,则当前线程需等待其被释放),待资源访问完后,再调用l.release方法释放锁!(https:
Wesley13 Wesley13
3年前
Java中的读写锁ReadWriteLock
ReadWriteLock是JDK中的读写锁接口ReentrantReadWriteLock是ReadWriteLock的一种实现读写锁非常适合读多写少的场景。读写锁与互斥锁的一个重要区别是读写锁允许多个线程同时读共享变量,这是读写锁在读多写少的情况下性能较高的原因。读写锁的原则:多个线程可同时读共享变量只允许一
Wesley13 Wesley13
3年前
Java中所有锁介绍
在读很多并发文章中,会提及各种各样锁如公平锁,乐观锁等等,这篇文章介绍各种锁的分类。介绍的内容如下:1.公平锁/非公平锁2.可重入锁/不可重入锁3.独享锁/共享锁4.互斥锁/读写锁5.乐观锁/悲观锁6.分段锁7.偏向锁/轻量级锁/重量级锁8.自旋锁上面是很多锁的名词,这些分类并不是全是指锁的
Stella981 Stella981
3年前
Linux 多线程
I.同步机制线程间的同步机制主要包括三个:互斥锁:以排他的方式,防止共享资源被并发访问;互斥锁为二元变量,状态为0开锁、1上锁;开锁必须由上锁的线程执行,不受其它线程干扰.条件变量:
码途觅汐使
码途觅汐使
Lv1
见到你的一瞬间,就像走了很远的路,终于到家了
文章
3
粉丝
0
获赞
0